Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

17.6 kB

import type {
  API,
  ArrowFunctionExpression,
  ASTPath,
  Collection,
  ExportDefaultDeclaration,
  ExportNamedDeclaration,
  FunctionDeclaration,
  FunctionExpression,
} from 'jscodeshift'

export const NEXTJS_ENTRY_FILES =
  /([\\/]|^)(page|layout|route|default)\.(t|j)sx?$/

export type FunctionScope =
  | FunctionDeclaration
  | FunctionExpression
  | ArrowFunctionExpression

export const NEXT_CODEMOD_ERROR_PREFIX = '@next-codemod-error'
const NEXT_CODEMOD_IGNORE_ERROR_PREFIX = '@next-codemod-ignore'

export const TARGET_ROUTE_EXPORTS = new Set([
  'GET',
  'POST',
  'PUT',
  'PATCH',
  'DELETE',
  'OPTIONS',
  'HEAD',
])

export const TARGET_NAMED_EXPORTS = new Set([
  // For page and layout
  'generateMetadata',
  'generateViewport',
  ...TARGET_ROUTE_EXPORTS,
])

export const TARGET_PROP_NAMES = new Set(['params', 'searchParams'])

export function isFunctionType(
  type: string
): type is
  | 'FunctionDeclaration'
  | 'FunctionExpression'
  | 'ArrowFunctionExpression' {
  return (
    type === 'FunctionDeclaration' ||
    type === 'FunctionExpression' ||
    type === 'ArrowFunctionExpression'
  )
}

export function isMatchedFunctionExported(
  path: ASTPath<FunctionDeclaration>,
  j: API['jscodeshift']
): boolean {
  const matchedFunctionNameFilter = (idName) => TARGET_NAMED_EXPORTS.has(idName)

  const directNamedExport = j(path).closest(j.ExportNamedDeclaration, {
    declaration: {
      type: 'FunctionDeclaration',
      id: {
        name: matchedFunctionNameFilter,
      },
    },
  })

  if (directNamedExport.size() > 0) {
    return true
  }

  // Check for default export (`export default function() {}`)
  const isDefaultExport = j(path).closest(j.ExportDefaultDeclaration).size() > 0
  if (isDefaultExport) {
    return true
  }

  // Look for named export elsewhere in the file (`export { <named> }`)
  const root = j(path).closestScope().closest(j.Program)
  const isNamedExport =
    root
      .find(j.ExportNamedDeclaration, {
        specifiers: [
          {
            type: 'ExportSpecifier',
            exported: {
              name: matchedFunctionNameFilter,
            },
          },
        ],
      })
      .size() > 0

  // Look for variable export but still function, e.g. `export const <named> = function() {}`,
  // also check if variable is a function or arrow function
  const isVariableExport =
    root
      .find(j.ExportNamedDeclaration, {
        declaration: {
          declarations: [
            {
              type: 'VariableDeclarator',
              id: {
                type: 'Identifier',
                name: matchedFunctionNameFilter,
              },
              init: {
                type: isFunctionType,
              },
            },
          ],
        },
      })
      .size() > 0

  if (isVariableExport) return true

  return isNamedExport
}

// directive is not parsed into AST, so we need to manually find it
// by going through the tokens. Use the 1st string token as the directive
export function determineClientDirective(root: Collection<any>, j: API['j']) {
  const { program } = root.get().node

  const directive = program.directives[0]
  if (j.Directive.check(directive)) {
    return directive.value.value === 'use client'
  }

  return false
}

export function isPromiseType(typeAnnotation) {
  return (
    typeAnnotation.type === 'TSTypeReference' &&
    typeAnnotation.typeName.name === 'Promise'
  )
}

export function turnFunctionReturnTypeToAsync(
  node: any,
  j: API['jscodeshift']
) {
  if (
    j.FunctionDeclaration.check(node) ||
    j.FunctionExpression.check(node) ||
    j.ArrowFunctionExpression.check(node)
  ) {
    if (node.returnType) {
      const returnTypeAnnotation = node.returnType.typeAnnotation
      const isReturnTypePromise = isPromiseType(returnTypeAnnotation)
      // Turn <return type> to Promise<return type>
      // e.g. () => { slug: string } to () => Promise<{ slug: string }>
      // e.g. Anything to Promise<Anything>
      if (!isReturnTypePromise) {
        if (
          node.returnType &&
          j.TSTypeAnnotation.check(node.returnType) &&
          (j.TSTypeReference.check(node.returnType.typeAnnotation) ||
            j.TSUnionType.check(node.returnType.typeAnnotation) ||
            j.TSTypePredicate.check(node.returnType.typeAnnotation))
        ) {
          // Change the return type to Promise<void>
          node.returnType.typeAnnotation = j.tsTypeReference(
            j.identifier('Promise'),
            // @ts-ignore ignore the super strict type checking on the type annotation
            j.tsTypeParameterInstantiation([returnTypeAnnotation])
          )
        }
      }
    }
  }
}

export function insertReactUseImport(root: Collection<any>, j: API['j']) {
  const hasReactUseImport =
    root
      .find(j.ImportSpecifier, {
        imported: {
          type: 'Identifier',
          name: 'use',
        },
      })
      .size() > 0

  if (!hasReactUseImport) {
    const reactImportDeclaration = root.find(j.ImportDeclaration, {
      source: {
        value: 'react',
      },
      // Skip the type only react imports
      importKind: 'value',
    })

    if (reactImportDeclaration.size() > 0) {
      const importNode = reactImportDeclaration.get().node

      // Add 'use' to existing 'react' import declaration
      importNode.specifiers.push(j.importSpecifier(j.identifier('use')))
    } else {
      // Final all type imports to 'react'
      if (reactImportDeclaration.size() > 0) {
        reactImportDeclaration
          .get()
          .node.specifiers.push(j.importSpecifier(j.identifier('use')))
      } else {
        // Add new import declaration for 'react' and 'use'
        root
          .get()
          .node.program.body.unshift(
            j.importDeclaration(
              [j.importSpecifier(j.identifier('use'))],
              j.literal('react')
            )
          )
      }
    }
  }
}

function findSubScopeArgumentIdentifier(
  path: ASTPath<any>,
  j: API['j'],
  argName: string
) {
  const defCount = j(path).find(j.Identifier, { name: argName }).size()

  return defCount > 0
}

export function generateUniqueIdentifier(
  defaultIdName: string,
  path: ASTPath<any>,
  j: API['j']
): ReturnType<typeof j.identifier> {
  let idName = defaultIdName
  let idNameSuffix = 0
  while (findSubScopeArgumentIdentifier(path, j, idName)) {
    idName = defaultIdName + idNameSuffix
    idNameSuffix++
  }

  const propsIdentifier = j.identifier(idName)
  return propsIdentifier
}

export function isFunctionScope(
  path: ASTPath,
  j: API['jscodeshift']
): path is ASTPath<FunctionScope> {
  if (!path) return false
  const node = path.node

  // Check if the node is a function (declaration, expression, or arrow function)
  return (
    j.FunctionDeclaration.check(node) ||
    j.FunctionExpression.check(node) ||
    j.ArrowFunctionExpression.check(node)
  )
}

export function findClosetParentFunctionScope(
  path: ASTPath,
  j: API['jscodeshift']
) {
  if (!path.scope) return null
  let parentFunctionPath = path.scope.path
  while (parentFunctionPath && !isFunctionScope(parentFunctionPath, j)) {
    parentFunctionPath = parentFunctionPath.parent
  }

  return parentFunctionPath
}

function getFunctionNodeFromBinding(
  bindingPath: ASTPath<any>,
  idName: string,
  j: API['jscodeshift'],
  root: Collection<any>
): ASTPath<FunctionScope> | undefined {
  const bindingNode = bindingPath.node
  if (
    j.FunctionDeclaration.check(bindingNode) ||
    j.FunctionExpression.check(bindingNode) ||
    j.ArrowFunctionExpression.check(bindingNode)
  ) {
    return bindingPath
  } else if (j.VariableDeclarator.check(bindingNode)) {
    const init = bindingNode.init
    // If the initializer is a function (arrow or function expression), record it
    if (
      j.FunctionExpression.check(init) ||
      j.ArrowFunctionExpression.check(init)
    ) {
      return bindingPath.get('init')
    }
  } else if (j.Identifier.check(bindingNode)) {
    const variablePath = root.find(j.VariableDeclaration, {
      // declarations, each is VariableDeclarator
      declarations: [
        {
          // VariableDeclarator
          type: 'VariableDeclarator',
          // id is Identifier
          id: {
            type: 'Identifier',
            name: idName,
          },
        },
      ],
    })

    if (variablePath.size()) {
      const variableDeclarator = variablePath.get()?.node?.declarations?.[0]
      if (j.VariableDeclarator.check(variableDeclarator)) {
        const init = variableDeclarator.init
        if (
          j.FunctionExpression.check(init) ||
          j.ArrowFunctionExpression.check(init)
        ) {
          return variablePath.get('declarations', 0, 'init')
        }
      }
    }

    const functionDeclarations = root.find(j.FunctionDeclaration, {
      id: {
        name: idName,
      },
    })
    if (functionDeclarations.size()) {
      return functionDeclarations.get()
    }
  }
  return undefined
}

export function getFunctionPathFromExportPath(
  exportPath: ASTPath<ExportDefaultDeclaration | ExportNamedDeclaration>,
  j: API['jscodeshift'],
  root: Collection<any>,
  namedExportFilter: (idName: string) => boolean
): ASTPath<FunctionScope> | undefined {
  // Default export
  if (j.ExportDefaultDeclaration.check(exportPath.node)) {
    const { declaration } = exportPath.node
    if (declaration) {
      if (
        j.FunctionDeclaration.check(declaration) ||
        j.FunctionExpression.check(declaration) ||
        j.ArrowFunctionExpression.check(declaration)
      ) {
        return exportPath.get('declaration')
      } else if (j.Identifier.check(declaration)) {
        const idName = declaration.name
        if (!namedExportFilter(idName)) return

        const exportBinding = exportPath.scope.getBindings()[idName]?.[0]
        if (exportBinding) {
          return getFunctionNodeFromBinding(exportBinding, idName, j, root)
        }
      }
    }
  } else if (
    // Named exports
    j.ExportNamedDeclaration.check(exportPath.node)
  ) {
    const namedExportPath = exportPath as ASTPath<ExportNamedDeclaration>
    // extract the named exports, name specifiers, and default specifiers
    const { declaration, specifiers } = namedExportPath.node
    if (declaration) {
      if (j.VariableDeclaration.check(declaration)) {
        const { declarations } = declaration
        for (const decl of declarations) {
          if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
            const idName = decl.id.name

            if (!namedExportFilter(idName)) return

            // get bindings for each variable declarator
            const exportBinding =
              namedExportPath.scope.getBindings()[idName]?.[0]
            if (exportBinding) {
              return getFunctionNodeFromBinding(exportBinding, idName, j, root)
            }
          }
        }
      } else if (
        j.FunctionDeclaration.check(declaration) ||
        j.FunctionExpression.check(declaration) ||
        j.ArrowFunctionExpression.check(declaration)
      ) {
        const funcName = declaration.id?.name
        if (!namedExportFilter(funcName)) return

        return namedExportPath.get('declaration')
      }
    }
    if (specifiers) {
      for (const specifier of specifiers) {
        if (j.ExportSpecifier.check(specifier)) {
          const idName = specifier.local.name

          if (!namedExportFilter(idName)) return

          const exportBinding = namedExportPath.scope.getBindings()[idName]?.[0]
          if (exportBinding) {
            return getFunctionNodeFromBinding(exportBinding, idName, j, root)
          }
        }
      }
    }
  }

  return undefined
}

export function wrapParentheseIfNeeded(
  hasChainAccess: boolean,
  j: API['jscodeshift'],
  expression
) {
  return hasChainAccess ? j.parenthesizedExpression(expression) : expression
}

function existsComment(
  comments: ASTPath<any>['node']['comments'],
  comment: string
): boolean {
  const isCodemodErrorComment = comment
    .trim()
    .startsWith(NEXT_CODEMOD_ERROR_PREFIX)

  let hasIgnoreComment = false
  let hasComment = false

  if (comments) {
    comments.forEach((commentNode) => {
      const currentComment = commentNode.value
      if (currentComment.trim().startsWith(NEXT_CODEMOD_IGNORE_ERROR_PREFIX)) {
        hasIgnoreComment = true
      }
      if (currentComment === comment) {
        hasComment = true
      }
    })
    // If it's inserting codemod error comment,
    // check if there's already a @next-codemod-ignore comment.
    // if ignore comment exists, bypass the comment insertion.
    if (hasIgnoreComment && isCodemodErrorComment) {
      return true
    }
    if (hasComment) {
      return true
    }
  }
  return false
}

export function insertCommentOnce(
  node: ASTPath<any>['node'],
  j: API['j'],
  comment: string
): boolean {
  const hasCommentInInlineComments = existsComment(node.comments, comment)
  const hasCommentInLeadingComments = existsComment(
    node.leadingComments,
    comment
  )

  if (!hasCommentInInlineComments && !hasCommentInLeadingComments) {
    // Always insert into inline comment
    node.comments = [j.commentBlock(comment), ...(node.comments || [])]
    return true
  }

  return false
}

export function getVariableDeclaratorId(
  path: ASTPath<any>,
  j: API['j']
): ASTPath<any>['node']['id'] | undefined {
  const parent = path.parentPath
  if (j.VariableDeclarator.check(parent.node)) {
    const id = parent.node.id
    if (j.Identifier.check(id)) {
      return id
    }
  }
  return undefined
}

export function findFunctionBody(path: ASTPath<FunctionScope>): null | any[] {
  let functionBody = path.node.body
  if (functionBody && functionBody.type === 'BlockStatement') {
    return functionBody.body
  }
  return null
}

const isPascalCase = (s: string) => /^[A-Z][a-z0-9]*$/.test(s)

export const isReactHookName = (name: string) =>
  // function name is `use`
  name === 'use' ||
  // function name is `useX*`
  (name.startsWith('use') && name[3] === name[3].toUpperCase())

// Determine a path of function contains any React hooks call expressions.
// e.g. if there's any of those call expressions in the function body:
// use() => true
// React.use() => false
// useXxxx() => true
// Foo.use() => true
// Foo.useXxxx() => true
export function containsReactHooksCallExpressions(
  path: ASTPath<FunctionScope>,
  j: API['jscodeshift']
) {
  const hasReactHooks =
    j(path)
      .find(j.CallExpression)
      .filter((callPath) => {
        // It's matching:
        // - use(<callPath>) => true
        // - useX*(<callPath>) => true
        const isUseHookOrReactHookCall =
          j.Identifier.check(callPath.value.callee) &&
          isReactHookName(callPath.value.callee.name)

        // It's matching member access:
        // - React.use(<callPath>) => true
        // - Foo.useFoo(<callPath>) => true
        // - foo.useFoo(<callPath>) => false
        // - foo.use(<callPath>) => false
        const isReactUseCall =
          j.MemberExpression.check(callPath.value.callee) &&
          j.Identifier.check(callPath.value.callee.object) &&
          j.Identifier.check(callPath.value.callee.property) &&
          isPascalCase(callPath.value.callee.object.name) &&
          isReactHookName(callPath.value.callee.property.name)

        return isUseHookOrReactHookCall || isReactUseCall
      })
      .size() > 0
  return hasReactHooks
}

// Capture the parent of the current path is wrapped by `use()` call expression
// e.g.
// use(<path>) => true
// use2(<path>) => false
// React.use(<path>) => true
// Robust.use(<path>) => false
export function isParentUseCallExpression(
  path: ASTPath<any>,
  j: API['jscodeshift']
) {
  const isParentUseCall =
    // member access parentPath is argument
    j.CallExpression.check(path.parent.value) &&
    // member access is first argument
    path.parent.value.arguments[0] === path.value &&
    path.parent.value.arguments.length === 1 &&
    // function name is `use`
    j.Identifier.check(path.parent.value.callee) &&
    path.parent.value.callee.name === 'use'
  const isParentReactUseCall =
    // member access parentPath is argument
    j.CallExpression.check(path.parent.value) &&
    // member access is first argument
    path.parent.value.arguments[0] === path.value &&
    path.parent.value.arguments.length === 1 &&
    // function name is `use`
    j.MemberExpression.check(path.parent.value.callee) &&
    j.Identifier.check(path.parent.value.callee.object) &&
    path.parent.value.callee.object.name === 'React' &&
    j.Identifier.check(path.parent.value.callee.property) &&
    path.parent.value.callee.property.name === 'use'
  return isParentUseCall || isParentReactUseCall
}

// Determine if a path is wrapped by `Promise.all()`
// e.g.
// Promise.all(<path>) => true
// Promise.allSettled(<path>) => false
export function isParentPromiseAllCallExpression(
  path: ASTPath<any>,
  j: API['jscodeshift']
) {
  const argsParent = path.parent
  const callParent = argsParent?.parent
  if (
    argsParent &&
    callParent &&
    j.ArrayExpression.check(argsParent.value) &&
    j.CallExpression.check(callParent.value) &&
    j.MemberExpression.check(callParent.value.callee) &&
    j.Identifier.check(callParent.value.callee.object) &&
    callParent.value.callee.object.name === 'Promise' &&
    j.Identifier.check(callParent.value.callee.property) &&
    callParent.value.callee.property.name === 'all'
  ) {
    return true
  }
  return false
}

	import type {
	API,
	ArrowFunctionExpression,
	ASTPath,
	Collection,
	ExportDefaultDeclaration,
	ExportNamedDeclaration,
	FunctionDeclaration,
	FunctionExpression,
	} from 'jscodeshift'

	export const NEXTJS_ENTRY_FILES =
	/([\\/]\|^)(page\|layout\|route\|default)\.(t\|j)sx?$/

	export type FunctionScope =
	\| FunctionDeclaration
	\| FunctionExpression
	\| ArrowFunctionExpression

	export const NEXT_CODEMOD_ERROR_PREFIX = '@next-codemod-error'
	const NEXT_CODEMOD_IGNORE_ERROR_PREFIX = '@next-codemod-ignore'

	export const TARGET_ROUTE_EXPORTS = new Set([
	'GET',
	'POST',
	'PUT',
	'PATCH',
	'DELETE',
	'OPTIONS',
	'HEAD',
	])

	export const TARGET_NAMED_EXPORTS = new Set([
	// For page and layout
	'generateMetadata',
	'generateViewport',
	...TARGET_ROUTE_EXPORTS,
	])

	export const TARGET_PROP_NAMES = new Set(['params', 'searchParams'])

	export function isFunctionType(
	type: string
	): type is
	\| 'FunctionDeclaration'
	\| 'FunctionExpression'
	\| 'ArrowFunctionExpression' {
	return (
	type === 'FunctionDeclaration' \|\|
	type === 'FunctionExpression' \|\|
	type === 'ArrowFunctionExpression'
	)
	}

	export function isMatchedFunctionExported(
	path: ASTPath<FunctionDeclaration>,
	j: API['jscodeshift']
	): boolean {
	const matchedFunctionNameFilter = (idName) => TARGET_NAMED_EXPORTS.has(idName)

	const directNamedExport = j(path).closest(j.ExportNamedDeclaration, {
	declaration: {
	type: 'FunctionDeclaration',
	id: {
	name: matchedFunctionNameFilter,
	},
	},
	})

	if (directNamedExport.size() > 0) {
	return true
	}

	// Check for default export (`export default function() {}`)
	const isDefaultExport = j(path).closest(j.ExportDefaultDeclaration).size() > 0
	if (isDefaultExport) {
	return true
	}

	// Look for named export elsewhere in the file (`export { <named> }`)
	const root = j(path).closestScope().closest(j.Program)
	const isNamedExport =
	root
	.find(j.ExportNamedDeclaration, {
	specifiers: [
	{
	type: 'ExportSpecifier',
	exported: {
	name: matchedFunctionNameFilter,
	},
	},
	],
	})
	.size() > 0

	// Look for variable export but still function, e.g. `export const <named> = function() {}`,
	// also check if variable is a function or arrow function
	const isVariableExport =
	root
	.find(j.ExportNamedDeclaration, {
	declaration: {
	declarations: [
	{
	type: 'VariableDeclarator',
	id: {
	type: 'Identifier',
	name: matchedFunctionNameFilter,
	},
	init: {
	type: isFunctionType,
	},
	},
	],
	},
	})
	.size() > 0

	if (isVariableExport) return true

	return isNamedExport
	}

	// directive is not parsed into AST, so we need to manually find it
	// by going through the tokens. Use the 1st string token as the directive
	export function determineClientDirective(root: Collection<any>, j: API['j']) {
	const { program } = root.get().node

	const directive = program.directives[0]
	if (j.Directive.check(directive)) {
	return directive.value.value === 'use client'
	}

	return false
	}

	export function isPromiseType(typeAnnotation) {
	return (
	typeAnnotation.type === 'TSTypeReference' &&
	typeAnnotation.typeName.name === 'Promise'
	)
	}

	export function turnFunctionReturnTypeToAsync(
	node: any,
	j: API['jscodeshift']
	) {
	if (
	j.FunctionDeclaration.check(node) \|\|
	j.FunctionExpression.check(node) \|\|
	j.ArrowFunctionExpression.check(node)
	) {
	if (node.returnType) {
	const returnTypeAnnotation = node.returnType.typeAnnotation
	const isReturnTypePromise = isPromiseType(returnTypeAnnotation)
	// Turn <return type> to Promise<return type>
	// e.g. () => { slug: string } to () => Promise<{ slug: string }>
	// e.g. Anything to Promise<Anything>
	if (!isReturnTypePromise) {
	if (
	node.returnType &&
	j.TSTypeAnnotation.check(node.returnType) &&
	(j.TSTypeReference.check(node.returnType.typeAnnotation) \|\|
	j.TSUnionType.check(node.returnType.typeAnnotation) \|\|
	j.TSTypePredicate.check(node.returnType.typeAnnotation))
	) {
	// Change the return type to Promise<void>
	node.returnType.typeAnnotation = j.tsTypeReference(
	j.identifier('Promise'),
	// @ts-ignore ignore the super strict type checking on the type annotation
	j.tsTypeParameterInstantiation([returnTypeAnnotation])
	)
	}
	}
	}
	}
	}

	export function insertReactUseImport(root: Collection<any>, j: API['j']) {
	const hasReactUseImport =
	root
	.find(j.ImportSpecifier, {
	imported: {
	type: 'Identifier',
	name: 'use',
	},
	})
	.size() > 0

	if (!hasReactUseImport) {
	const reactImportDeclaration = root.find(j.ImportDeclaration, {
	source: {
	value: 'react',
	},
	// Skip the type only react imports
	importKind: 'value',
	})

	if (reactImportDeclaration.size() > 0) {
	const importNode = reactImportDeclaration.get().node

	// Add 'use' to existing 'react' import declaration
	importNode.specifiers.push(j.importSpecifier(j.identifier('use')))
	} else {
	// Final all type imports to 'react'
	if (reactImportDeclaration.size() > 0) {
	reactImportDeclaration
	.get()
	.node.specifiers.push(j.importSpecifier(j.identifier('use')))
	} else {
	// Add new import declaration for 'react' and 'use'
	root
	.get()
	.node.program.body.unshift(
	j.importDeclaration(
	[j.importSpecifier(j.identifier('use'))],
	j.literal('react')
	)
	)
	}
	}
	}
	}

	function findSubScopeArgumentIdentifier(
	path: ASTPath<any>,
	j: API['j'],
	argName: string
	) {
	const defCount = j(path).find(j.Identifier, { name: argName }).size()

	return defCount > 0
	}

	export function generateUniqueIdentifier(
	defaultIdName: string,
	path: ASTPath<any>,
	j: API['j']
	): ReturnType<typeof j.identifier> {
	let idName = defaultIdName
	let idNameSuffix = 0
	while (findSubScopeArgumentIdentifier(path, j, idName)) {
	idName = defaultIdName + idNameSuffix
	idNameSuffix++
	}

	const propsIdentifier = j.identifier(idName)
	return propsIdentifier
	}

	export function isFunctionScope(
	path: ASTPath,
	j: API['jscodeshift']
	): path is ASTPath<FunctionScope> {
	if (!path) return false
	const node = path.node

	// Check if the node is a function (declaration, expression, or arrow function)
	return (
	j.FunctionDeclaration.check(node) \|\|
	j.FunctionExpression.check(node) \|\|
	j.ArrowFunctionExpression.check(node)
	)
	}

	export function findClosetParentFunctionScope(
	path: ASTPath,
	j: API['jscodeshift']
	) {
	if (!path.scope) return null
	let parentFunctionPath = path.scope.path
	while (parentFunctionPath && !isFunctionScope(parentFunctionPath, j)) {
	parentFunctionPath = parentFunctionPath.parent
	}

	return parentFunctionPath
	}

	function getFunctionNodeFromBinding(
	bindingPath: ASTPath<any>,
	idName: string,
	j: API['jscodeshift'],
	root: Collection<any>
	): ASTPath<FunctionScope> \| undefined {
	const bindingNode = bindingPath.node
	if (
	j.FunctionDeclaration.check(bindingNode) \|\|
	j.FunctionExpression.check(bindingNode) \|\|
	j.ArrowFunctionExpression.check(bindingNode)
	) {
	return bindingPath
	} else if (j.VariableDeclarator.check(bindingNode)) {
	const init = bindingNode.init
	// If the initializer is a function (arrow or function expression), record it
	if (
	j.FunctionExpression.check(init) \|\|
	j.ArrowFunctionExpression.check(init)
	) {
	return bindingPath.get('init')
	}
	} else if (j.Identifier.check(bindingNode)) {
	const variablePath = root.find(j.VariableDeclaration, {
	// declarations, each is VariableDeclarator
	declarations: [
	{
	// VariableDeclarator
	type: 'VariableDeclarator',
	// id is Identifier
	id: {
	type: 'Identifier',
	name: idName,
	},
	},
	],
	})

	if (variablePath.size()) {
	const variableDeclarator = variablePath.get()?.node?.declarations?.[0]
	if (j.VariableDeclarator.check(variableDeclarator)) {
	const init = variableDeclarator.init
	if (
	j.FunctionExpression.check(init) \|\|
	j.ArrowFunctionExpression.check(init)
	) {
	return variablePath.get('declarations', 0, 'init')
	}
	}
	}

	const functionDeclarations = root.find(j.FunctionDeclaration, {
	id: {
	name: idName,
	},
	})
	if (functionDeclarations.size()) {
	return functionDeclarations.get()
	}
	}
	return undefined
	}

	export function getFunctionPathFromExportPath(
	exportPath: ASTPath<ExportDefaultDeclaration \| ExportNamedDeclaration>,
	j: API['jscodeshift'],
	root: Collection<any>,
	namedExportFilter: (idName: string) => boolean
	): ASTPath<FunctionScope> \| undefined {
	// Default export
	if (j.ExportDefaultDeclaration.check(exportPath.node)) {
	const { declaration } = exportPath.node
	if (declaration) {
	if (
	j.FunctionDeclaration.check(declaration) \|\|
	j.FunctionExpression.check(declaration) \|\|
	j.ArrowFunctionExpression.check(declaration)
	) {
	return exportPath.get('declaration')
	} else if (j.Identifier.check(declaration)) {
	const idName = declaration.name
	if (!namedExportFilter(idName)) return

	const exportBinding = exportPath.scope.getBindings()[idName]?.[0]
	if (exportBinding) {
	return getFunctionNodeFromBinding(exportBinding, idName, j, root)
	}
	}
	}
	} else if (
	// Named exports
	j.ExportNamedDeclaration.check(exportPath.node)
	) {
	const namedExportPath = exportPath as ASTPath<ExportNamedDeclaration>
	// extract the named exports, name specifiers, and default specifiers
	const { declaration, specifiers } = namedExportPath.node
	if (declaration) {
	if (j.VariableDeclaration.check(declaration)) {
	const { declarations } = declaration
	for (const decl of declarations) {
	if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
	const idName = decl.id.name

	if (!namedExportFilter(idName)) return

	// get bindings for each variable declarator
	const exportBinding =
	namedExportPath.scope.getBindings()[idName]?.[0]
	if (exportBinding) {
	return getFunctionNodeFromBinding(exportBinding, idName, j, root)
	}
	}
	}
	} else if (
	j.FunctionDeclaration.check(declaration) \|\|
	j.FunctionExpression.check(declaration) \|\|
	j.ArrowFunctionExpression.check(declaration)
	) {
	const funcName = declaration.id?.name
	if (!namedExportFilter(funcName)) return

	return namedExportPath.get('declaration')
	}
	}
	if (specifiers) {
	for (const specifier of specifiers) {
	if (j.ExportSpecifier.check(specifier)) {
	const idName = specifier.local.name

	if (!namedExportFilter(idName)) return

	const exportBinding = namedExportPath.scope.getBindings()[idName]?.[0]
	if (exportBinding) {
	return getFunctionNodeFromBinding(exportBinding, idName, j, root)
	}
	}
	}
	}
	}

	return undefined
	}

	export function wrapParentheseIfNeeded(
	hasChainAccess: boolean,
	j: API['jscodeshift'],
	expression
	) {
	return hasChainAccess ? j.parenthesizedExpression(expression) : expression
	}

	function existsComment(
	comments: ASTPath<any>['node']['comments'],
	comment: string
	): boolean {
	const isCodemodErrorComment = comment
	.trim()
	.startsWith(NEXT_CODEMOD_ERROR_PREFIX)

	let hasIgnoreComment = false
	let hasComment = false

	if (comments) {
	comments.forEach((commentNode) => {
	const currentComment = commentNode.value
	if (currentComment.trim().startsWith(NEXT_CODEMOD_IGNORE_ERROR_PREFIX)) {
	hasIgnoreComment = true
	}
	if (currentComment === comment) {
	hasComment = true
	}
	})
	// If it's inserting codemod error comment,
	// check if there's already a @next-codemod-ignore comment.
	// if ignore comment exists, bypass the comment insertion.
	if (hasIgnoreComment && isCodemodErrorComment) {
	return true
	}
	if (hasComment) {
	return true
	}
	}
	return false
	}

	export function insertCommentOnce(
	node: ASTPath<any>['node'],
	j: API['j'],
	comment: string
	): boolean {
	const hasCommentInInlineComments = existsComment(node.comments, comment)
	const hasCommentInLeadingComments = existsComment(
	node.leadingComments,
	comment
	)

	if (!hasCommentInInlineComments && !hasCommentInLeadingComments) {
	// Always insert into inline comment
	node.comments = [j.commentBlock(comment), ...(node.comments \|\| [])]
	return true
	}

	return false
	}

	export function getVariableDeclaratorId(
	path: ASTPath<any>,
	j: API['j']
	): ASTPath<any>['node']['id'] \| undefined {
	const parent = path.parentPath
	if (j.VariableDeclarator.check(parent.node)) {
	const id = parent.node.id
	if (j.Identifier.check(id)) {
	return id
	}
	}
	return undefined
	}

	export function findFunctionBody(path: ASTPath<FunctionScope>): null \| any[] {
	let functionBody = path.node.body
	if (functionBody && functionBody.type === 'BlockStatement') {
	return functionBody.body
	}
	return null
	}

	const isPascalCase = (s: string) => /^[A-Z][a-z0-9]*$/.test(s)

	export const isReactHookName = (name: string) =>
	// function name is `use`
	name === 'use' \|\|
	// function name is `useX*`
	(name.startsWith('use') && name[3] === name[3].toUpperCase())

	// Determine a path of function contains any React hooks call expressions.
	// e.g. if there's any of those call expressions in the function body:
	// use() => true
	// React.use() => false
	// useXxxx() => true
	// Foo.use() => true
	// Foo.useXxxx() => true
	export function containsReactHooksCallExpressions(
	path: ASTPath<FunctionScope>,
	j: API['jscodeshift']
	) {
	const hasReactHooks =
	j(path)
	.find(j.CallExpression)
	.filter((callPath) => {
	// It's matching:
	// - use(<callPath>) => true
	// - useX*(<callPath>) => true
	const isUseHookOrReactHookCall =
	j.Identifier.check(callPath.value.callee) &&
	isReactHookName(callPath.value.callee.name)

	// It's matching member access:
	// - React.use(<callPath>) => true
	// - Foo.useFoo(<callPath>) => true
	// - foo.useFoo(<callPath>) => false
	// - foo.use(<callPath>) => false
	const isReactUseCall =
	j.MemberExpression.check(callPath.value.callee) &&
	j.Identifier.check(callPath.value.callee.object) &&
	j.Identifier.check(callPath.value.callee.property) &&
	isPascalCase(callPath.value.callee.object.name) &&
	isReactHookName(callPath.value.callee.property.name)

	return isUseHookOrReactHookCall \|\| isReactUseCall
	})
	.size() > 0
	return hasReactHooks
	}

	// Capture the parent of the current path is wrapped by `use()` call expression
	// e.g.
	// use(<path>) => true
	// use2(<path>) => false
	// React.use(<path>) => true
	// Robust.use(<path>) => false
	export function isParentUseCallExpression(
	path: ASTPath<any>,
	j: API['jscodeshift']
	) {
	const isParentUseCall =
	// member access parentPath is argument
	j.CallExpression.check(path.parent.value) &&
	// member access is first argument
	path.parent.value.arguments[0] === path.value &&
	path.parent.value.arguments.length === 1 &&
	// function name is `use`
	j.Identifier.check(path.parent.value.callee) &&
	path.parent.value.callee.name === 'use'
	const isParentReactUseCall =
	// member access parentPath is argument
	j.CallExpression.check(path.parent.value) &&
	// member access is first argument
	path.parent.value.arguments[0] === path.value &&
	path.parent.value.arguments.length === 1 &&
	// function name is `use`
	j.MemberExpression.check(path.parent.value.callee) &&
	j.Identifier.check(path.parent.value.callee.object) &&
	path.parent.value.callee.object.name === 'React' &&
	j.Identifier.check(path.parent.value.callee.property) &&
	path.parent.value.callee.property.name === 'use'
	return isParentUseCall \|\| isParentReactUseCall
	}

	// Determine if a path is wrapped by `Promise.all()`
	// e.g.
	// Promise.all(<path>) => true
	// Promise.allSettled(<path>) => false
	export function isParentPromiseAllCallExpression(
	path: ASTPath<any>,
	j: API['jscodeshift']
	) {
	const argsParent = path.parent
	const callParent = argsParent?.parent
	if (
	argsParent &&
	callParent &&
	j.ArrayExpression.check(argsParent.value) &&
	j.CallExpression.check(callParent.value) &&
	j.MemberExpression.check(callParent.value.callee) &&
	j.Identifier.check(callParent.value.callee.object) &&
	callParent.value.callee.object.name === 'Promise' &&
	j.Identifier.check(callParent.value.callee.property) &&
	callParent.value.callee.property.name === 'all'
	) {
	return true
	}
	return false
	}