Merge branch 'next'

Author: Septh

package.json

@@ -7,7 +7,6 @@
     "Tomer Aberbach <[email protected]>",
     "Elad Ossadon <[email protected]>"
   ],
-  "license": "MIT",
   "keywords": [
     "rollup",
     "rollup-plugin",
@@ -22,14 +21,15 @@
     "package.json",
     "monorepo"
   ],
-  "engines": {
-    "node": ">=14.0.0"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/Septh/rollup-plugin-node-externals"
   },
   "homepage": "https://github.com/Septh/rollup-plugin-node-externals",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "type": "commonjs",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -61,9 +61,6 @@
   "dependencies": {
     "find-up": "^6.2.0"
   },
-  "peerDependencies": {
-    "rollup": "^2.60.1"
-  },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-node-resolve": "^13.0.6",
@@ -72,6 +69,7 @@
     "fast-check": "^2.20.0",
     "rimraf": "^3.0.2",
     "rollup-plugin-ts": "^2.0.4",
+    "rollup": "^2.60.1",
     "ts-node": "^10.4.0",
     "tslib": "^2.3.1",
     "tslint": "^6.1.2",

rollup.config.mjs

@@ -1,6 +1,6 @@
 // @ts-check
 import { dirname } from 'path'
-import { builtinModules as external, createRequire } from 'module'
+import { builtinModules, createRequire } from 'module'
 import resolve from '@rollup/plugin-node-resolve'
 import commonjs from '@rollup/plugin-commonjs'
 import ts from 'rollup-plugin-ts'
@@ -9,13 +9,12 @@ import ts from 'rollup-plugin-ts'
 const pkg = createRequire(import.meta.url)('./package.json')
 
 /**
- * A mini-plugin that resolves `node:` imports to their unprefixed equivalent.
+ * A mini-plugin that resolves `node:` and `nodejs:` imports to their unprefixed equivalent.
  * @type { import('rollup').PluginImpl }
  */
 function nodeColon() {
     return {
         name: 'node-colon',
-
         resolveId(id) {
             for (const scheme of [ 'node:', 'nodejs:' ]) {
                 if (id.startsWith(scheme)) {
@@ -28,16 +27,16 @@ function nodeColon() {
 
 /**
  * A mini-plugin that generates a package.json file next to the bundle.
- * @type { import('rollup').PluginImpl }
+ * @type { import('rollup').PluginImpl<'module' | 'commonjs'> }
  */
-function emitModulePackageFile() {
+function emitPkg(type) {
     return {
         name: 'emit-module-package-file',
         generateBundle() {
             this.emitFile({
                 type: 'asset',
                 fileName: 'package.json',
-                source: JSON.stringify({ type: 'module' }, undefined, 2)
+                source: JSON.stringify({ type }, undefined, 2)
             })
         }
     }
@@ -51,14 +50,15 @@ const config = {
             format: 'commonjs',
             file: pkg.main,
             exports: 'named',
-            sourcemap: false
+            plugins: [
+                emitPkg('commonjs')
+            ],
         },
         {
             format: 'module',
             file: pkg.module,
-            sourcemap: false,
             plugins: [
-                emitModulePackageFile()
+                emitPkg('module')
             ]
         },
     ],
@@ -73,7 +73,7 @@ const config = {
             })
         })
     ],
-    external
+    external: builtinModules.concat(Object.keys(pkg.dependencies))
 }
 
 export default config

src/index.ts

@@ -34,11 +34,8 @@ export interface ExternalsOptions {
  */
  export default function externals(options: ExternalsOptions = {}): Plugin {
 
-    // Store eventual warnings until we can display them
-    const warnings: string[] = []
-
     // Consolidate options
-    const opts: Required<ExternalsOptions> = {
+    const consolidatedOptions: Required<ExternalsOptions> = {
         packagePath: [],
         builtins: true,
         deps: false,
@@ -50,9 +47,12 @@ export interface ExternalsOptions {
         ...options
     }
 
+    // This will store all eventual warnings until we can display them
+    const warnings: string[] = []
+
     // Map the include and exclude options to arrays of regexes
-    const [ include, exclude ] = [ 'include', 'exclude' ].map(option => new Array()
-        .concat((opts as any)[option])
+    const [ include, exclude ] = [ 'include', 'exclude' ].map(optionName => new Array()
+        .concat((consolidatedOptions as any)[optionName])
         .map((entry: string | RegExp, index: number): RegExp => {
             if (entry instanceof RegExp) {
                 return entry
@@ -62,68 +62,69 @@ export interface ExternalsOptions {
             }
             else {
                 if (!!entry) {
-                    warnings.push(`Ignoring wrong entry type #${index} in '${option}' option: '${entry}'`)
+                    warnings.push(`Ignoring wrong entry type #${index} in '${optionName}' option: '${entry}'`)
                 }
                 return /(?=no)match/
             }
         })
     )
 
-    // Build a function to filter out unwanted dependencies
-    const filterFn = (dep: string) => !exclude.some(rx => rx.test(dep))
+    // Build a function to keep only non excluded dependencies
+    const isNotExcluded = (id: string) => !exclude.some(rx => rx.test(id))
 
-    // Filter NodeJS builtins
-    const builtins = (opts.builtins ? builtinModules : []).filter(filterFn)
-
-    // Normalize package paths
-    let packagePaths: string[] = ([] as string[]).concat(opts.packagePath)
-
-    // Array of the final regexes, include potential import from a sub directory (e.g. 'lodash/map')
+    // Array of the final regexes
     const externals: RegExp[] = []
+    const isExternal = (id: string) => externals.some(deps => deps.test(id))
 
     return {
         name: 'node-externals',
 
         async buildStart() {
 
-            // Find and filter dependencies
+            // 1) Filter NodeJS builtins, supporting potential import from a sub directory (e.g. 'fs/promises')
+            const builtins = (consolidatedOptions.builtins ? builtinModules : []).filter(isNotExcluded)
+            if (builtins.length > 0) {
+                externals.push(new RegExp('^(?:' + builtins.join('|') + ')(\/.+)?$'))
+            }
+
+            // 2) Find and filter dependencies, supporting potential import from a sub directory (e.g. 'lodash/map')
+            const packagePaths: string[] = ([] as string[]).concat(consolidatedOptions.packagePath)
             const dependencies = (await findDependencies({
                 packagePaths: packagePaths.length > 0 ? packagePaths : findPackagePaths(),
                 keys: [
-                    opts.deps && 'dependencies',
-                    opts.devDeps && 'devDependencies',
-                    opts.peerDeps && 'peerDependencies',
-                    opts.optDeps && 'optionalDependencies'
+                    consolidatedOptions.deps && 'dependencies',
+                    consolidatedOptions.devDeps && 'devDependencies',
+                    consolidatedOptions.peerDeps && 'peerDependencies',
+                    consolidatedOptions.optDeps && 'optionalDependencies'
                 ].filter(Boolean) as string[],
                 warnings
-            })).filter(filterFn)
-
-            // Issue the warnings we may have collected
-            let msg: string | undefined
-            while (msg = warnings.shift()) {
-                this.warn(msg)
-            }
-
-            // Build regexes
-            if (builtins.length > 0) {
-                externals.push(new RegExp('^(?:' + builtins.join('|') + ')(\/.+)?$'))
-            }
+            })).filter(isNotExcluded)
 
             if (dependencies.length > 0) {
                 externals.push(new RegExp('^(?:' + dependencies.join('|') + ')(\/.+)?$'))
             }
 
+            // 3) Add the include option
             if (include.length > 0) {
                 externals.push(...include)
             }
+
+            // All done. Issue the warnings we may have collected
+            let msg: string | undefined
+            while (msg = warnings.shift()) {
+                this.warn(msg)
+            }
         },
 
         resolveId(id, importer) {
+            // Ignore entry chunks & don't mess with other plugins
+            if (!importer?.charCodeAt(0) || !id.charCodeAt(0)) {
+                return null
+            }
+
             // Return `false` if importee should be treated as an external module,
-            // otherwise return `null` to let Rollup and other plugins handle it.
-            return importer && !/\0/.test(id) && externals.some(deps => deps.test(id)) && filterFn(id)
-                ? false
-                : null
+            // otherwise return `null` to let Rollup and other plugins handle it
+            return isExternal(id) && isNotExcluded(id) ? false : null
         }
     }
 }

tsconfig.json

@@ -34,8 +34,8 @@
             // "strictFunctionTypes": true,
             // "strictPropertyInitialization": true,
 		"noImplicitReturns": true,
-		"noUnusedLocals": true,
-        "noUnusedParameters": true,
+		"noUnusedLocals": false,
+        "noUnusedParameters": false,
     },
     "files": [
         "src/index.ts"