Home

Index

How to use the importDefaultSpecifier function from @babel/types

Find comprehensive JavaScript @babel/types.importDefaultSpecifier code examples handpicked from public code repositorys.

The @babel/types.importDefaultSpecifier is a function provided by the Babel library that represents a default import specifier in an abstract syntax tree (AST) node.

index.js

154
155
156
157
158
159
160
161
162

if (name === 'default') {
    localName = 'styled' in BINDINGS ? '_styled' : 'styled';

    IMPORT.specifiers.push(
        t.importDefaultSpecifier(t.identifier(localName)),
    );
} else {
    localName = name in BINDINGS ? `_${name}` : name;

363

+ 29 other calls in file

taroEntryInjectLoader.js

GitHub: AntmJS/antm

19
20
21
22
23
24
25
26
27
28
// 对 ast 进行深度遍历
traverse(ast, {
  Program(path) {
    const node = t.importDeclaration(
      [
        t.importDefaultSpecifier(
          t.identifier('{ isInIcestark, setLibraryName }'),
        ),
      ],
      t.stringLiteral('@ice/stark-app'),

How does @babel/types.importDefaultSpecifier work?

The @babel/types.importDefaultSpecifier is a function provided by the Babel library that represents a default import specifier in an abstract syntax tree (AST) node. An import default specifier is used to import the default export from a module, and can be used in the import statement in JavaScript/TypeScript code. When creating an AST node using Babel, importDefaultSpecifier can be used to create a new node representing a default import specifier. The function takes in an object with the following properties: local: The local name of the default import specifier. imported: The imported name of the default import specifier (which will be the string "default"). The returned node is an instance of the ImportDefaultSpecifier class in the Babel AST, and can be used in constructing a larger AST representing the imported module. Overall, @babel/types.importDefaultSpecifier provides a way to create an AST node representing a default import specifier in JavaScript/TypeScript code, which can be useful in cases where you need to programmatically generate code or perform transformations on an existing AST.

uniq-imports.js

GitHub: markdown-doc/react-markdown-doc-loader

53
54
55
56
57
58
59
60
61
62
    ]
  );
}

function createImportDefaultSpecifier(id) {
  return types.importDefaultSpecifier(types.identifier(id));
}

function createImportNamespaceSpecifier(id) {
  return types.importNamespaceSpecifier(types.identifier(id));

astHelper.js

GitHub: ice-lab/scaffold-generator

9
10
11
12
13
14
15
16
17
18
const lastImportIndex = _.findLastIndex(body, (item) => t.isImportDeclaration(item));

const importSpecifiers = (Array.isArray(specifiers) ? specifiers : [specifiers]).map((specifier) => {
  return specifier.imported
    ? t.importSpecifier(t.identifier(specifier.local), t.identifier(specifier.imported))
    : t.importDefaultSpecifier(t.identifier(specifier));
});
const newImport = t.importDeclaration(
  importSpecifiers,
  t.stringLiteral(importPath),

Ai Example

1
2
3
4
5
const t = require("@babel/types");

const specifier = t.importDefaultSpecifier(t.identifier("myModule"));

console.log(specifier);

In this example, we use @babel/types.importDefaultSpecifier to create a new AST node representing a default import specifier. We first import the @babel/types library and assign it to the variable t. We then call the importDefaultSpecifier function provided by t, passing in an object with a local property set to an identifier node with the value 'myModule'. This creates a new instance of the ImportDefaultSpecifier class in the Babel AST, which represents a default import specifier with a local name of myModule. We log the resulting node to the console to show its structure and properties. Note that in order to use @babel/types.importDefaultSpecifier, you need to have the Babel library installed and imported in your application.

%E9%A1%B9%E7%9B%AE%E5%B7%A5%E7%A8%8B%E5%8C%96%E4%B8%8ENode.md?plain=1

GitHub: huxingyi1997/hexo

310
311
312
313
314
315
316
317
318

  ```
  /**
   * @param {Identifier} local  (required)
   */
  t.importDefaultSpecifier(local)
  ```

- 在 `importDeclaration` 中还需要生成一个 `StringLiteral`

+ 51 other calls in file

import.js

GitHub: dancon/babel-plugin-react-css-modules

37
38
39
40
41
42
43
44
45
46
  }
}

const identifier = types.identifier(importSpec)
const importedIdent = types.identifier(imported)
const classNameDefSpec = importDefault ? types.importDefaultSpecifier(identifier) : types.importSpecifier(identifier, importedIdent)
const classnamesImpo = types.importDeclaration([ classNameDefSpec ], types.stringLiteral(importSrc))
program.unshiftContainer('body', classnamesImpo)

return importSpec

taro-declarate.js

GitHub: chuhui1/vueToReact

11
12
13
14
15
16
17
18
19
20
      collect.imports.push(path.node)
    },
})

const ImportDeclarationTaro = t.importDeclaration([
    t.importDefaultSpecifier(t.identifier('Taro')),
    t.importSpecifier(t.identifier('Component'), t.identifier('Component'))
], t.stringLiteral('@tarojs/taro'))
if (Object.keys(state.props).length) {
    const importPropTypes = t.importDeclaration(

+ 3 other calls in file

transt.js

GitHub: perfectyang/auto-inject-loader

11
12
13
14
15
16
17
18
19
20
    temArr.push(
      t.importSpecifier(t.identifier(cur.name), t.identifier(cur.name))
    )
  } else if (cur.key === 'default') {
    temArr.unshift(
      t.importDefaultSpecifier(t.identifier(cur.name))
    )
  }
})
return t.importDeclaration(temArr, t.stringLiteral(url))

+ 3 other calls in file

generator.cjs

GitHub: Airkro/road-to-rome

22
23
24
25
26
27
28
29
30
31
return items.map(({ from, source, to }) =>
  t.importDeclaration(
    [
      from
        ? t.importSpecifier(t.identifier(to), t.identifier(from))
        : t.importDefaultSpecifier(t.identifier(to)),
    ],
    t.stringLiteral(source),
  ),
);

+ 4 other calls in file

custom-visitor.js

GitHub: kood-codes/py-to-js

235
236
237
238
239
240
241
242
243
244
    importValItem = t.importSpecifier(
      t.identifier(terminalchildren.pop()),
      t.identifier(terminalchildren.shift())
    );
  } else {
    importValItem = t.importDefaultSpecifier(
      t.identifier(child.getText())
    );
  }
}

index.js

GitHub: saltires/saltire-lerna

44
45
46
47
48
49
50
51
52
53
ImportDeclaration(nodePath) {
  const { specifiers } = nodePath.node;
  if (!t.isImportDefaultSpecifier(specifiers[0]) && specifiers.length > 0) {
    const importDeclarations = specifiers.map((item) => {
      if (t.isImportSpecifier(item)) {
        const importDefaultSpecifier = t.importDefaultSpecifier(item.local);
        const source = t.stringLiteral(`${nodePath.node.source.value}/${item.local.name}`);
        return t.importDeclaration([importDefaultSpecifier], source);
      }
    });

babel.ts

GitHub: occmundial/atomic

46
47
48
49
50
51
52
53
54
55
function importGeneric(path, dir) {
  const importsList = getImportsList(path)
  const importStatements = importsList.map(function (specifier) {
    const importName = specifier.imported.name
    return importDeclaration(
      types.importDefaultSpecifier(types.identifier(importName)),
      `@occmundial/atomic/${dir}/${importName}`
    )
  })
  replaceImport(path, importStatements)

+ 15 other calls in file

typedefs.js

GitHub: groupon/esfixup

143
144
145
146
147
148
149
150
151
152
stmts.unshift(
  t.importDeclaration(
    [
      key
        ? t.importSpecifier(t.identifier(alias), t.identifier(key))
        : t.importDefaultSpecifier(t.identifier(alias)),
    ],
    t.stringLiteral(mod)
  )
);

+ 3 other calls in file

Other functions in @babel/types

Sorted by popularity

@babel/types.identifier is the most popular function in @babel/types (20936 examples)

Other popular packages:

Home

About