Refactor to get all exports

Author: aryaemami59

.size-limit.mts

@@ -1,17 +1,47 @@
-import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { Check, SizeLimitConfig } from 'size-limit'
+import type { Configuration } from 'webpack'
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 
+const packageJsonEntryPoints = new Set<string>()
+
+const getPackageJsonExports = async (
+  packageJsonExports:
+    | string
+    | Record<string, any>
+    | null
+    | typeof import('./package.json').exports,
+) => {
+  if (typeof packageJsonExports === 'string') {
+    packageJsonEntryPoints.add(
+      packageJsonExports.startsWith('./')
+        ? packageJsonExports
+        : `./${packageJsonExports}`,
+    )
+
+    return packageJsonEntryPoints
+  }
+
+  if (typeof packageJsonExports === 'object' && packageJsonExports !== null) {
+    await Promise.all(
+      Object.entries(packageJsonExports)
+        .filter(
+          ([condition]) =>
+            condition !== './package.json' && condition !== 'types',
+        )
+        .map(([_condition, entryPoint]) => entryPoint)
+        .map(getPackageJsonExports),
+    )
+  }
+
+  return packageJsonEntryPoints
+}
+
 const getAllPackageEntryPoints = async () => {
   const packageJson = await import('./package.json', { with: { type: 'json' } })
 
-  const packageExports = Object.entries(packageJson.exports['.'])
-    .filter(([condition]) => condition !== 'types')
-    .map(([_condition, entryPoint]) =>
-      path.isAbsolute(entryPoint) ? `./${entryPoint}` : entryPoint,
-    )
+  const packageExports = await getPackageJsonExports(packageJson.exports)
 
   return [...new Set(packageExports)]
 }
@@ -20,63 +50,69 @@ const getAllImports = async (
   entryPoint: string,
   index: number,
 ): Promise<SizeLimitConfig> => {
-  const allNamedImports = await import(entryPoint)
+  const allNamedImports: typeof import('./src/index') = await import(entryPoint)
 
   return Object.keys(allNamedImports)
     .map<Check>((namedImport) => ({
       path: entryPoint,
-      name: `import { ${namedImport} } from "${entryPoint}"`,
+      name: `${index + 1}. import { ${namedImport} } from "${entryPoint}"`,
       import: `{ ${namedImport} }`,
-      modifyWebpackConfig: (config) => {
-        config.optimization.nodeEnv = 'development'
-        return config
-      },
     }))
     .concat([
       {
         path: entryPoint,
-        name: `import * from "${entryPoint}"`,
+        name: `${index + 1}. import * from "${entryPoint}"`,
         import: '*',
       },
       {
         path: entryPoint,
-        name: `import "${entryPoint}"`,
+        name: `${index + 1}. import "${entryPoint}"`,
       },
     ])
 }
 
-const setNodeEnv = (
-  nodeEnv: 'development' | 'production',
-): Check['modifyWebpackConfig'] => {
-  return (config) => {
-    config.optimization.nodeEnv = nodeEnv
+const allNodeEnvs = ['development', 'production'] as const
+
+type NodeEnv = (typeof allNodeEnvs)[number]
+
+const setNodeEnv = (nodeEnv: NodeEnv) => {
+  const modifyWebpackConfig = ((config: Configuration) => {
+    ;(config.optimization ??= {}).nodeEnv = nodeEnv
     return config
-  }
+  }) satisfies Check['modifyWebpackConfig']
+
+  return modifyWebpackConfig
 }
 
-const getAllImportsWithNodeEnv = async (
-  nodeEnv: 'development' | 'production',
-) => {
+const getAllImportsWithNodeEnv = async (nodeEnv: NodeEnv) => {
   const allPackageEntryPoints = await getAllPackageEntryPoints()
 
   const allImportsFromAllEntryPoints = (
     await Promise.all(allPackageEntryPoints.map(getAllImports))
   ).flat()
 
-  const allImportsWithNodeEnv = allImportsFromAllEntryPoints.map(
+  const modifyWebpackConfig = setNodeEnv(nodeEnv)
+
+  const allImportsWithNodeEnv = allImportsFromAllEntryPoints.map<Check>(
     (importsFromEntryPoint) => ({
       ...importsFromEntryPoint,
       name: `${importsFromEntryPoint.name} ('${nodeEnv}' mode)`,
-      modifyWebpackConfig: setNodeEnv(nodeEnv),
+      modifyWebpackConfig,
     }),
   )
 
   return allImportsWithNodeEnv
 }
 
-const allNodeEnvs = ['development', 'production'] as const
+const getSizeLimitConfig = async (): Promise<SizeLimitConfig> => {
+  const sizeLimitConfig = (
+    await Promise.all(allNodeEnvs.map(getAllImportsWithNodeEnv))
+  ).flat()
+
+  return sizeLimitConfig
+}
 
 const sizeLimitConfig: Promise<SizeLimitConfig> = (async () =>
-  (await Promise.all(allNodeEnvs.map(getAllImportsWithNodeEnv))).flat())()
+  await getSizeLimitConfig())()
 
 export default sizeLimitConfig