next-auto-import 0.0.0

package/src/core/ctx.ts

@@ -0,0 +1,287 @@
+import { existsSync, promises as fs } from 'node:fs'
+import { dirname, isAbsolute, relative, resolve } from 'node:path'
+import process from 'node:process'
+import { slash, toArray } from '@antfu/utils'
+import { isPackageExists } from 'local-pkg'
+import { createUnimport, resolvePreset } from 'unimport'
+import { presets } from '../presets'
+import { generateBiomeLintConfigs } from './biomelintrc'
+import { generateESLintConfigs } from './eslintrc'
+import { resolversAddon } from './resolvers'
+import type { Import, InlinePreset } from 'unimport'
+import type { BiomeLintrc, ESLintrc, Options } from '../types'
+
+export const INCLUDE_RE_LIST = [/\.[jt]sx?$/]
+export const EXCLUDE_RE_LIST = [/[\\/]node_modules[\\/]/, /[\\/]\.git[\\/]/]
+
+export function createContext(options: Options = {}, root = process.cwd()) {
+  root = slash(root)
+
+  const {
+    dts: preferDTS = isPackageExists('typescript'),
+    dtsMode = 'append',
+    dtsPreserveExts = false,
+    dirsScanOptions,
+    dirs,
+  } = options
+
+  const eslintrc: ESLintrc = options.eslintrc || {}
+  eslintrc.enabled = eslintrc.enabled === undefined ? false : eslintrc.enabled
+  eslintrc.filepath = eslintrc.filepath || './.eslintrc-auto-import.json'
+  eslintrc.globalsPropValue =
+    eslintrc.globalsPropValue === undefined ? true : eslintrc.globalsPropValue
+
+  const biomelintrc: BiomeLintrc = options.biomelintrc || {}
+  biomelintrc.enabled = biomelintrc.enabled !== undefined
+  biomelintrc.filepath =
+    biomelintrc.filepath || './.biomelintrc-auto-import.json'
+
+  const dumpUnimportItems =
+    options.dumpUnimportItems === true
+      ? './.unimport-items.json'
+      : (options.dumpUnimportItems ?? false)
+
+  const resolvers = options.resolvers ? [options.resolvers].flat(2) : []
+
+  // When "options.injectAtEnd" is undefined or true, it's true.
+  const injectAtEnd = options.injectAtEnd !== false
+
+  const unimport = createUnimport({
+    imports: [],
+    presets:
+      options.packagePresets?.map((p) =>
+        typeof p === 'string' ? { package: p } : p,
+      ) ?? [],
+    dirsScanOptions: {
+      ...dirsScanOptions,
+      cwd: root,
+    },
+    dirs,
+    injectAtEnd,
+    parser: options.parser,
+    addons: {
+      addons: [
+        resolversAddon(resolvers),
+        {
+          name: 'unplugin-auto-import:dts',
+          declaration(dts) {
+            return `${`
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+// Generated by unplugin-auto-import
+// biome-ignore lint: disable
+${dts}`.trim()}\n`
+          },
+        },
+      ],
+    },
+  })
+
+  const importsPromise = flattenImports(options.imports).then((imports) => {
+    if (!imports.length && !resolvers.length && !dirs?.length)
+      console.warn(
+        '[auto-import] plugin installed but no imports has defined, see https://github.com/antfu/unplugin-auto-import#configurations for configurations',
+      )
+
+    const compare = (
+      left: string | undefined,
+      right: NonNullable<Options['ignore'] | Options['ignoreDts']>[number],
+    ) => {
+      return right instanceof RegExp ? right.test(left!) : right === left
+    }
+
+    options.ignore?.forEach((name) => {
+      const i = imports.find((i) => compare(i.as, name))
+      if (i) i.disabled = true
+    })
+
+    options.ignoreDts?.forEach((name) => {
+      const i = imports.find((i) => compare(i.as, name))
+      if (i) i.dtsDisabled = true
+    })
+
+    return unimport.getInternalContext().replaceImports(imports)
+  })
+
+  const dts =
+    preferDTS === false
+      ? false
+      : preferDTS === true
+        ? resolve(root, 'auto-imports.d.ts')
+        : resolve(root, preferDTS)
+
+  const multilineCommentsRE = /\/\*.*?\*\//gs
+  const singlelineCommentsRE = /\/\/.*$/gm
+  const dtsReg = /declare\s+global\s*\{(.*?)[\n\r]\}/s
+  function parseDTS(dts: string) {
+    dts = dts.replace(multilineCommentsRE, '').replace(singlelineCommentsRE, '')
+
+    const code = dts.match(dtsReg)?.[0]
+    if (!code) return
+
+    return Object.fromEntries(
+      Array.from(
+        code.matchAll(/['"]?(const\s*[^\s'"]+)['"]?\s*:\s*(.+?)[,;\r\n]/g),
+      ).map((i) => [i[1], i[2]]),
+    )
+  }
+
+  async function generateDTS(file: string) {
+    await importsPromise
+    const dir = dirname(file)
+    const originalContent = existsSync(file)
+      ? await fs.readFile(file, 'utf-8')
+      : ''
+    const originalDTS = parseDTS(originalContent)
+    const currentContent = await unimport.generateTypeDeclarations({
+      resolvePath: (i) => {
+        if (i.from.startsWith('.') || isAbsolute(i.from)) {
+          const related = slash(
+            dtsPreserveExts
+              ? relative(dir, i.from)
+              : relative(dir, i.from).replace(/\.ts(x)?$/, ''),
+          )
+          return !related.startsWith('.') ? `./${related}` : related
+        }
+        return i.from
+      },
+    })
+
+    if (dtsMode === 'append') {
+      const currentDTS = parseDTS(currentContent)!
+      if (originalDTS) {
+        Object.assign(originalDTS, currentDTS)
+
+        const dtsList = Object.keys(originalDTS)
+          .sort()
+          .map((k) => `  ${k}: ${originalDTS[k]}`)
+        return currentContent.replace(
+          dtsReg,
+          () => `declare global {\n${dtsList.join('\n')}\n}`,
+        )
+      }
+    }
+
+    return currentContent
+  }
+
+  async function generateESLint() {
+    return generateESLintConfigs(await unimport.getImports(), eslintrc)
+  }
+
+  async function generateBiomeLint() {
+    return generateBiomeLintConfigs(await unimport.getImports())
+  }
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping
+  async function writeFile(filePath: string, content = '') {
+    await fs.mkdir(dirname(filePath), { recursive: true })
+    return await fs.writeFile(filePath, content, 'utf-8')
+  }
+
+  let lastDTS: string | undefined
+  let lastESLint: string | undefined
+  let lastBiomeLint: string | undefined
+  let lastUnimportItems: string | undefined
+
+  async function writeConfigFiles() {
+    const promises: any[] = []
+    if (dts) {
+      promises.push(
+        generateDTS(dts).then((content) => {
+          if (content !== lastDTS) {
+            lastDTS = content
+            return writeFile(dts, content)
+          }
+        }),
+      )
+    }
+    if (eslintrc.enabled && eslintrc.filepath) {
+      const filepath = eslintrc.filepath
+      promises.push(
+        generateESLint().then(async (content) => {
+          if (filepath.endsWith('.cjs')) content = `module.exports = ${content}`
+          else if (filepath.endsWith('.mjs') || filepath.endsWith('.js'))
+            content = `export default ${content}`
+
+          content = `${content}\n`
+          if (content.trim() !== lastESLint?.trim()) {
+            lastESLint = content
+            return writeFile(eslintrc.filepath!, content)
+          }
+        }),
+      )
+    }
+
+    if (biomelintrc.enabled) {
+      promises.push(
+        generateBiomeLint().then((content) => {
+          if (content !== lastBiomeLint) {
+            lastBiomeLint = content
+            return writeFile(biomelintrc.filepath!, content)
+          }
+        }),
+      )
+    }
+
+    if (dumpUnimportItems) {
+      promises.push(
+        unimport.getImports().then((items) => {
+          if (!dumpUnimportItems) return
+          const content = JSON.stringify(items, null, 2)
+          if (content !== lastUnimportItems) {
+            lastUnimportItems = content
+            return writeFile(dumpUnimportItems, content)
+          }
+        }),
+      )
+    }
+
+    return Promise.all(promises)
+  }
+
+  return {
+    writeConfigFiles,
+  }
+}
+
+export async function flattenImports(
+  map: Options['imports'],
+): Promise<Import[]> {
+  const promises = await Promise.all(
+    toArray(map).map(async (definition) => {
+      if (typeof definition === 'string') {
+        if (!presets[definition])
+          throw new Error(`[auto-import] preset ${definition} not found`)
+        const preset = presets[definition]
+        definition = preset
+      }
+
+      if ('from' in definition && 'imports' in definition) {
+        return await resolvePreset(definition as InlinePreset)
+      } else {
+        const resolved: Import[] = []
+        for (const mod of Object.keys(definition)) {
+          for (const id of definition[mod]) {
+            const meta = {
+              from: mod,
+            } as Import
+            if (Array.isArray(id)) {
+              meta.name = id[0]
+              meta.as = id[1]
+            } else {
+              meta.name = id
+              meta.as = id
+            }
+            resolved.push(meta)
+          }
+        }
+        return resolved
+      }
+    }),
+  )
+
+  return promises.flat()
+}

package/src/core/eslintrc.ts

@@ -0,0 +1,16 @@
+import type { Import } from 'unimport'
+import type { ESLintrc } from '../types'
+
+export function generateESLintConfigs(imports: Import[], eslintrc: ESLintrc) {
+  const eslintConfigs: any = { globals: {} }
+
+  imports
+    .map((i) => i.as ?? i.name)
+    .filter(Boolean)
+    .sort()
+    .forEach((name) => {
+      eslintConfigs.globals[name] = eslintrc.globalsPropValue
+    })
+  const jsonBody = JSON.stringify(eslintConfigs, null, 2)
+  return jsonBody
+}

package/src/core/resolvers.ts

@@ -0,0 +1,94 @@
+import { toArray } from '@antfu/utils'
+import type { Addon, Import } from 'unimport'
+import type {
+  ImportExtended,
+  ImportLegacy,
+  Resolver,
+  ResolverResult,
+} from '../types'
+
+export function normalizeImport(
+  info: Import | ResolverResult | ImportExtended | ImportLegacy | string,
+  name: string,
+): ImportExtended {
+  if (typeof info === 'string') {
+    return {
+      name: 'default',
+      as: name,
+      from: info,
+    }
+  }
+  if ('path' in info) {
+    return {
+      from: info.path,
+      as: info.name,
+      name: info.importName!,
+      sideEffects: info.sideEffects,
+    }
+  }
+  return {
+    name,
+    as: name,
+    ...info,
+  }
+}
+
+export async function firstMatchedResolver(
+  resolvers: Resolver[],
+  fullname: string,
+) {
+  let name = fullname
+  for (const resolver of resolvers) {
+    if (typeof resolver === 'object' && resolver.type === 'directive') {
+      if (name.startsWith('v')) name = name.slice(1)
+      else continue
+    }
+    const resolved = await (typeof resolver === 'function'
+      ? resolver(name)
+      : resolver.resolve(name))
+    if (resolved) return normalizeImport(resolved, fullname)
+  }
+}
+
+export function resolversAddon(resolvers: Resolver[]): Addon {
+  return {
+    name: 'unplugin-auto-import:resolvers',
+    async matchImports(names, matched) {
+      if (!resolvers.length) return
+      const dynamic: ImportExtended[] = []
+      const sideEffects: ImportExtended[] = []
+      await Promise.all(
+        [...names].map(async (name) => {
+          const matchedImport = matched.find((i) => i.as === name)
+          if (matchedImport) {
+            if ('sideEffects' in matchedImport)
+              sideEffects.push(
+                ...toArray((matchedImport as ImportExtended).sideEffects).map(
+                  (i) => normalizeImport(i, ''),
+                ),
+              )
+
+            return
+          }
+          const resolved = await firstMatchedResolver(resolvers, name)
+          if (resolved) dynamic.push(resolved)
+
+          if (resolved?.sideEffects)
+            sideEffects.push(
+              ...toArray(resolved?.sideEffects).map((i) =>
+                normalizeImport(i, ''),
+              ),
+            )
+        }),
+      )
+
+      if (dynamic.length) {
+        this.dynamicImports.push(...dynamic)
+        this.invalidate()
+      }
+
+      if (dynamic.length || sideEffects.length)
+        return [...matched, ...dynamic, ...sideEffects]
+    },
+  }
+}

package/src/core/unplugin.ts

@@ -0,0 +1,80 @@
+import { slash } from '@antfu/utils'
+import { isPackageExists } from 'local-pkg'
+import pm from 'picomatch'
+import { createUnplugin } from 'unplugin'
+import { createContext, EXCLUDE_RE_LIST, INCLUDE_RE_LIST } from './ctx'
+import type { FilterPattern } from 'unplugin'
+import type { Options } from '../types'
+
+export default createUnplugin<Options>((options) => {
+  let ctx = createContext(options)
+  return {
+    name: 'unplugin-auto-import',
+    enforce: 'post',
+    transformInclude(id) {
+      return ctx.filter(id)
+    },
+    transform: {
+      filter: {
+        id: {
+          include: (options.include as FilterPattern) || INCLUDE_RE_LIST,
+          exclude: (options.exclude as FilterPattern) || EXCLUDE_RE_LIST,
+        },
+      },
+      async handler(code, id) {
+        return ctx.transform(code, id)
+      },
+    },
+    async buildStart() {
+      await ctx.scanDirs()
+    },
+    async buildEnd() {
+      await ctx.writeConfigFiles()
+    },
+    vite: {
+      async config(config) {
+        if (options.viteOptimizeDeps === false) return
+
+        const exclude = config.optimizeDeps?.exclude || []
+
+        const imports = new Set(
+          (await ctx.unimport.getImports())
+            .map((i) => i.from)
+            .filter(
+              (i) =>
+                i.match(/^[a-z@]/) &&
+                !exclude.includes(i) &&
+                isPackageExists(i),
+            ),
+        )
+
+        if (!imports.size) return
+
+        return {
+          optimizeDeps: {
+            include: [...imports],
+          },
+        }
+      },
+      async handleHotUpdate({ file }) {
+        if (!ctx.dirs?.length) return
+
+        if (ctx.configFilePaths.includes(file)) return
+
+        const normalizedFilePath = slash(file)
+
+        const shouldRescan = ctx.normalizedDirPaths.some((dirPath) =>
+          pm.isMatch(normalizedFilePath, dirPath.glob),
+        )
+
+        if (shouldRescan) await ctx.scanDirs()
+      },
+      async configResolved(config) {
+        if (ctx.root !== config.root) {
+          ctx = createContext(options, config.root)
+          await ctx.scanDirs()
+        }
+      },
+    },
+  }
+})

package/src/index.ts

@@ -0,0 +1,30 @@
+import { createContext } from './core/ctx'
+import type { NextConfig } from 'next'
+import type { Options } from './types'
+
+/**
+ * Creates a Next.js auto-import context
+ */
+export function createAutoImport(options: Options = {}) {
+  const ctx = createContext(options)
+
+  ctx.writeConfigFiles()
+
+  return (nextConfig: NextConfig = {}): NextConfig => {
+    return {
+      ...nextConfig,
+      experimental: {
+        ...nextConfig.experimental,
+        swcPlugins: [
+          [
+            'swc-plugin-auto-import',
+            {
+              presets: ['react'],
+            },
+          ],
+          ...(nextConfig.experimental?.swcPlugins ?? []),
+        ],
+      },
+    }
+  }
+}

package/src/presets/index.ts

@@ -0,0 +1,9 @@
+import react from './react'
+import reactDom from './react-dom'
+
+export const presets = {
+  'react': react,
+  'react-dom': reactDom,
+}
+
+export type PresetName = keyof typeof presets

package/src/presets/react-dom.ts

@@ -0,0 +1,15 @@
+import type { ImportsMap } from '../types'
+
+export default {
+  'react-dom': [
+    'useFormStatus',
+    'createPortal',
+    'flushSync',
+    'preconnect',
+    'prefetchDNS',
+    'preinit',
+    'preinitModule',
+    'preload',
+    'preloadModule',
+  ],
+} as const satisfies ImportsMap

package/src/presets/react.ts

@@ -0,0 +1,40 @@
+import type { ImportsMap } from '../types'
+
+export const CommonReactAPI = [
+  'useState',
+  'useCallback',
+  'useMemo',
+  'useEffect',
+  'useRef',
+  'useContext',
+  'useReducer',
+  'useImperativeHandle',
+  'useDebugValue',
+  'useDeferredValue',
+  'useLayoutEffect',
+  'useTransition',
+  'startTransition',
+  'useSyncExternalStore',
+  'useInsertionEffect',
+  'useId',
+  'lazy',
+  'memo',
+  'createRef',
+  'forwardRef',
+] as const
+
+export default {
+  react: [
+    ...CommonReactAPI,
+    'cache',
+    'cacheSignal',
+    'createContext',
+    'use',
+    'useOptimistic',
+    'useEffectEvent',
+    'useActionState',
+    'Fragment',
+    'Suspense',
+    'Activity',
+  ],
+} as const satisfies ImportsMap