es-info

Analyze ES module and extract information about imports, exports, and dynamic imports.

Usage

1const {Parser} = require("acorn");
2const {analyze} = require("es-info");
3
4const code = `
5import foo from "foo";
6import {bar} from "bar";
7import * as baz from "baz";
8
9export default "bar";
10export const boo = "boo";
11export {bla} from "bla";
12
13if (foo === "doSomething") {
14  import("dynamic-imported")
15    .then(module => module.doSomething());
16}
17`;
18const ast = Parser.parse(code, {sourceType: "module", ecmaVersion: 2022});
19
20const result = await analyze({ast, subtree: true});

Result:

1{
2  import: {
3    foo: {
4      default: true,
5      named: [],
6      all: false,
7      used: ["default"]
8    },
9    bar: {
10      default: false,
11      named: ["bar"],
12      all: false,
13      used: []
14    },
15    baz: {
16      default: false,
17      named: [],
18      all: true,
19      used: []
20    },
21    bla: {
22      default: false,
23      named: ["bla"],
24      all: false,
25      used: []
26    }
27  },
28  export: {
29    default: true,
30    named: ["boo", "bla"],
31    all: false
32  },
33  dynamicImport: ["dynamic-imported"]
34}

API reference

This module exports following members.

• analyze: A function which can analyze an AST and extract imports, exports information.

analyze

1async analyze({
2  ast,
3  subtree?: boolean
4}) => {
5  import: {
6    [importee]: {
7      default: boolean,
8      named: Array<string>,
9      all: boolean,
10      used: Array<string>
11    }
12  }
13  export: {
14    default: boolean,
15    named: Array<string>,
16    all: boolean
17  },
18  dynamicImport: Array<string>
19}

options

• ast is an estree object.
• subtree - if true, the analyzer will analyze the entire tree, otherwise only those top-level nodes (import/export declarations) are analyzed. You have to set subtree to true if you want to collect the usage of imported names and to collect dynamic imports. Default: false.

result.import

• result.import is an importee -> importInfo object map.

• result.import[importee].default - if true then the default member is imported from the importee module.

• result.import[importee].named contains a list of imported names.

• result.import[importee].all - if true then all names are imported from the module i.e. import * from ....

• result.import[importee].used is an array of imported names. If a name is included in this array, then it is referenced somewhere in the code. You can use this array to determine which names are actually used when .all is true.

  Note that export {foo} from "bar" doesn't use foo.

result.export

• result.export.default - if true then the module exports a default member.
• result.export.named is a list of exported names.
• result.export.all - if true then the module exports all members from another module e.g. export * from "foo".

result.dynamicImport

• dynamicImport is a list of module ID which are imported with dynamic import() statement.

Changelog

• 0.4.0 (Aug 8, 2022)

  • Bump dependencies.
  • Change: analyze is now an async function.
  • Fix: support ImportExpression.

• 0.3.0 (Jun 13, 2019)

  • Breaking: the signature of analyze() is changed.
  • Add: subtree option.

• 0.2.1 (Jun 6, 2019)

  • Fix: rename .scope to ._esInfoScope to avoid the conflict.

• 0.2.0 (Jun 6, 2019)

  • Breaking: drop options.dynamicImport. Now the module always analyze the entire tree.
  • Add: importInfo.used. Use it to check which names are used.

• 0.1.1 (Apr 29, 2018)

  • Fix: ClassDeclaration.

• 0.1.0 (Apr 28, 2018)

  • Initial release.