Function processFactory

packages/nuxt/src/compiler/plugins/keyed-function-factories.ts:132–223

(
    walkContext: ThisParameterType<NonNullable<Parameters<typeof walk>[1]['enter']>>, // TODO: export type from `oxc-walker`
    node: ExportNamedDeclaration | ExportDefaultDeclaration,
    handler: (ctx: { parseFactoryResult: ParsedKeyedFunctionFactory, factory: KeyedFunctionFactory }) => void,
  )

  }

  function processFactory (
    walkContext: ThisParameterType<NonNullable<Parameters<typeof walk>[1]['enter']>>, // TODO: export type from `oxc-walker`
    node: ExportNamedDeclaration | ExportDefaultDeclaration,
    handler: (ctx: { parseFactoryResult: ParsedKeyedFunctionFactory, factory: KeyedFunctionFactory }) => void,
  ) {
    const parsedFactoryCalls = parseKeyedFunctionFactory(node, LOCAL_FACTORY_NAMES_RE, scopeTracker)
    if (!parsedFactoryCalls.length) { return }

    for (const parsedFactoryCall of parsedFactoryCalls) {
      const factoryMeta = getFactoryByLocalName(parsedFactoryCall.factoryName)
      if (!factoryMeta) {
        logger.error(`[nuxt:compiler] No factory function found for \`${parsedFactoryCall.functionName}\` in file \`${filePath}\`. This is a Nuxt bug.`)
        continue
      }

      const scopeTrackerNode = scopeTracker.getDeclaration(!parsedFactoryCall.namespace ? parsedFactoryCall.factoryName : parsedFactoryCall.namespace)

      function isFactoryImport (node: ScopeTrackerNode | null): node is ScopeTrackerNode & { type: 'Import' } {
        return node?.type === 'Import' && node.importNode.importKind !== 'type'
      }

      // import source WITHOUT EXTENSION and with resolved alias
      let importSourceResolved: string | undefined

      if (isFactoryImport(scopeTrackerNode)) {
        importSourceResolved = stripExtension(_resolvePath(scopeTrackerNode.importNode.source.value))
      } else if (!scopeTrackerNode) {
        const autoImportedSource = autoImportsToSources?.get(factoryMeta.name)
        if (autoImportedSource) {
          importSourceResolved = stripExtension(_resolvePath(autoImportedSource))
        }
      }

      if (!importSourceResolved) {
        continue
      }

      // resolved source WITHOUT an extension
      const resolvedFactorySource = factoryMeta.source

      // the factory is called directly
      // `createUseFetch()`
      if (
        !parsedFactoryCall.namespace && (
          // and the factory is imported directly
          (
            isFactoryImport(scopeTrackerNode) && (
              (
                // import { createUseFetch } from '...'
                scopeTrackerNode.node.type === 'ImportSpecifier'
                && scopeTrackerNode.node.importKind !== 'type'
              )
              // import createUseFetch from '...'
              || (
                scopeTrackerNode.node.type === 'ImportDefaultSpecifier'
                && factoryMeta.name === 'default'
              )
            )