Function handler

packages/nuxt/src/compiler/plugins/keyed-function-factories.ts:427–498

(code, id)

        code: { include: KEYED_FUNCTION_FACTORY_NAMES_RE },
      },
      async handler (code, id) {
        const s = new MagicString(code)
        const scopeTracker = new ScopeTracker({
          preserveExitedScopes: true,
        })
        const autoImports = await options.getAutoImports()
        const autoImportsToSources = new Map<string, string>(autoImports.map(i => [i.as || i.name, i.from]))
        const { processFactory } = createFactoryProcessor(
          id,
          scopeTracker,
          namesToFactoryMeta,
          findStaticImports(code).map(i => parseStaticImport(i)),
          autoImportsToSources,
          options.alias,
        )

        function rewriteFactoryMacro (node: IdentifierReference | MemberExpression | ParenthesizedExpression) {
          // TODO: use sth more robust for rewriting optionals
          if (node.type === 'Identifier') {
            // createUseFetch?.() -> createUseFetch?.__nuxt_factory()
            if (code[node.end] === '?' && code[node.end + 1] === '.') {
              s.overwrite(
                node.start,
                node.end + 2,
                `${node.name}?.__nuxt_factory`,
              )
            } else {
              // createUseFetch() -> createUseFetch.__nuxt_factory()
              s.overwrite(
                node.start,
                node.end,
                `${node.name}.__nuxt_factory`,
              )
            }
          } else if (code[node.end] === '?' && code[node.end + 1] === '.') {
            // ['createUseFetch']?.() -> ['createUseFetch']?.__nuxt_factory()
            s.appendLeft(node.end + 2, '__nuxt_factory')
          } else {
            // ['createUseFetch']() -> ['createUseFetch'].__nuxt_factory()
            s.appendLeft(node.end, '.__nuxt_factory')
          }
        }

        const { program } = parseAndWalk(code, id, {
          scopeTracker,
        })

        scopeTracker.freeze()

        walk(program, {
          // no need for a scope tracker pre-pass, since we only care about imports
          // and we only consider the root scope (because that's where an export would be - so no shadowing)
          scopeTracker,
          enter (node) {
            if (node.type !== 'ExportNamedDeclaration' && node.type !== 'ExportDefaultDeclaration') {
              return
            }
            processFactory(this, node, ({ parseFactoryResult }) => {