in packages/metro-transform-plugins/src/import-export-plugin.js [149:576]
function importExportPlugin({types: t}: {types: Types, ...}): PluginObj<State> {
const {isDeclaration, isVariableDeclaration} = t;
return {
visitor: {
ExportAllDeclaration(
path: NodePath<BabelNodeExportAllDeclaration>,
state: State,
): void {
state.exportAll.push({
file: path.node.source.value,
loc: path.node.loc,
});
path.remove();
},
ExportDefaultDeclaration(
path: NodePath<BabelNodeExportDefaultDeclaration>,
state: State,
): void {
const declaration = path.node.declaration;
const id =
declaration.id || path.scope.generateUidIdentifier('default');
// $FlowFixMe Flow error uncovered by typing Babel more strictly
declaration.id = id;
const loc = path.node.loc;
state.exportDefault.push({
local: id.name,
loc,
});
if (isDeclaration(declaration)) {
path.insertBefore(withLocation(declaration, loc));
} else {
path.insertBefore(
withLocation(
t.variableDeclaration('var', [
t.variableDeclarator(id, declaration),
]),
loc,
),
);
}
path.remove();
},
ExportNamedDeclaration(
path: NodePath<ExportNamedDeclaration>,
state: State,
): void {
if (path.node.exportKind && path.node.exportKind !== 'value') {
return;
}
const declaration = path.node.declaration;
const loc = path.node.loc;
if (declaration) {
if (isVariableDeclaration(declaration)) {
declaration.declarations.forEach(d => {
switch (d.id.type) {
case 'ObjectPattern':
{
const properties = d.id.properties;
properties.forEach(p => {
// $FlowFixMe Flow error uncovered by typing Babel more strictly
const name = p.key.name;
// $FlowFixMe[incompatible-call]
state.exportNamed.push({local: name, remote: name, loc});
});
}
break;
case 'ArrayPattern':
{
const elements = d.id.elements;
elements.forEach(e => {
// $FlowFixMe Flow error uncovered by typing Babel more strictly
const name = e.name;
// $FlowFixMe[incompatible-call]
state.exportNamed.push({local: name, remote: name, loc});
});
}
break;
default:
{
// $FlowFixMe Flow error uncovered by typing Babel more strictly
const name = d.id.name;
// $FlowFixMe[incompatible-call]
state.exportNamed.push({local: name, remote: name, loc});
}
break;
}
});
} else {
const id = declaration.id || path.scope.generateUidIdentifier();
// $FlowFixMe Flow error uncovered by typing Babel more strictly
const name = id.name;
// $FlowFixMe Flow error uncovered by typing Babel more strictly
declaration.id = id;
// $FlowFixMe[incompatible-call]
state.exportNamed.push({local: name, remote: name, loc});
}
path.insertBefore(declaration);
}
const specifiers = path.node.specifiers;
if (specifiers) {
specifiers.forEach(s => {
// $FlowFixMe Flow error uncovered by typing Babel more strictly
const local = s.local;
const remote = s.exported;
if (remote.type === 'StringLiteral') {
// https://babeljs.io/docs/en/babel-plugin-syntax-module-string-names
throw path.buildCodeFrameError(
'Module string names are not supported',
);
}
if (path.node.source) {
// $FlowFixMe[incompatible-use]
const temp = path.scope.generateUidIdentifier(local.name);
// $FlowFixMe[incompatible-type]
if (local.name === 'default') {
path.insertBefore(
withLocation(
importTemplate({
IMPORT: t.cloneNode(state.importDefault),
FILE: resolvePath(
t.cloneNode(nullthrows(path.node.source)),
state.opts.resolve,
),
LOCAL: temp,
}),
loc,
),
);
state.exportNamed.push({
local: temp.name,
remote: remote.name,
loc,
});
} else if (remote.name === 'default') {
path.insertBefore(
withLocation(
importNamedTemplate({
FILE: resolvePath(
t.cloneNode(nullthrows(path.node.source)),
state.opts.resolve,
),
LOCAL: temp,
REMOTE: local,
}),
loc,
),
);
state.exportDefault.push({local: temp.name, loc});
} else {
path.insertBefore(
withLocation(
importNamedTemplate({
FILE: resolvePath(
t.cloneNode(nullthrows(path.node.source)),
state.opts.resolve,
),
LOCAL: temp,
REMOTE: local,
}),
loc,
),
);
state.exportNamed.push({
local: temp.name,
remote: remote.name,
loc,
});
}
} else {
if (remote.name === 'default') {
// $FlowFixMe[incompatible-use]
state.exportDefault.push({local: local.name, loc});
} else {
state.exportNamed.push({
// $FlowFixMe[incompatible-use]
local: local.name,
remote: remote.name,
loc,
});
}
}
});
}
path.remove();
},
ImportDeclaration(path: NodePath<ImportDeclaration>, state: State): void {
if (path.node.importKind && path.node.importKind !== 'value') {
return;
}
const file = path.node.source;
const specifiers = path.node.specifiers;
const loc = path.node.loc;
if (!specifiers.length) {
state.imports.push({
node: withLocation(
importSideEffectTemplate({
FILE: resolvePath(t.cloneNode(file), state.opts.resolve),
}),
loc,
),
});
} else {
let sharedModuleImport;
let sharedModuleVariableDeclaration = null;
if (
specifiers.filter(
s =>
s.type === 'ImportSpecifier' &&
(s.imported.type === 'StringLiteral' ||
s.imported.name !== 'default'),
).length > 1
) {
sharedModuleImport =
path.scope.generateUidIdentifierBasedOnNode(file);
sharedModuleVariableDeclaration = withLocation(
t.variableDeclaration('var', [
t.variableDeclarator(
t.cloneNode(sharedModuleImport),
t.callExpression(t.identifier('require'), [
resolvePath(t.cloneNode(file), state.opts.resolve),
]),
),
]),
loc,
);
state.imports.push({node: sharedModuleVariableDeclaration});
}
specifiers.forEach(s => {
// $FlowFixMe Flow error uncovered by typing Babel more strictly
const imported = s.imported;
const local = s.local;
switch (s.type) {
case 'ImportNamespaceSpecifier':
state.imports.push({
node: withLocation(
importTemplate({
IMPORT: t.cloneNode(state.importAll),
FILE: resolvePath(t.cloneNode(file), state.opts.resolve),
LOCAL: t.cloneNode(local),
}),
loc,
),
});
break;
case 'ImportDefaultSpecifier':
state.imports.push({
node: withLocation(
importTemplate({
IMPORT: t.cloneNode(state.importDefault),
FILE: resolvePath(t.cloneNode(file), state.opts.resolve),
LOCAL: t.cloneNode(local),
}),
loc,
),
});
break;
case 'ImportSpecifier':
// $FlowFixMe[incompatible-type]
if (imported.name === 'default') {
state.imports.push({
node: withLocation(
importTemplate({
IMPORT: t.cloneNode(state.importDefault),
FILE: resolvePath(
t.cloneNode(file),
state.opts.resolve,
),
LOCAL: t.cloneNode(local),
}),
loc,
),
});
} else if (sharedModuleVariableDeclaration != null) {
sharedModuleVariableDeclaration.declarations.push(
withLocation(
t.variableDeclarator(
t.cloneNode(local),
t.memberExpression(
t.cloneNode(sharedModuleImport),
// $FlowFixMe[incompatible-call]
t.cloneNode(imported),
),
),
loc,
),
);
} else {
state.imports.push({
node: withLocation(
importNamedTemplate({
FILE: resolvePath(
t.cloneNode(file),
state.opts.resolve,
),
LOCAL: t.cloneNode(local),
REMOTE: t.cloneNode(imported),
}),
loc,
),
});
}
break;
default:
throw new TypeError('Unknown import type: ' + s.type);
}
});
}
path.remove();
},
Program: {
enter(path: NodePath<Program>, state: State): void {
state.exportAll = [];
state.exportDefault = [];
state.exportNamed = [];
state.imports = [];
state.importAll = t.identifier(state.opts.importAll);
state.importDefault = t.identifier(state.opts.importDefault);
},
exit(path: NodePath<Program>, state: State): void {
const body = path.node.body;
// state.imports = [node1, node2, node3, ...nodeN]
state.imports.reverse().forEach((e: {node: Statement}) => {
// import nodes are added to the top of the program body
body.unshift(e.node);
});
state.exportDefault.forEach(
(e: {local: string, loc: ?BabelSourceLocation, ...}) => {
body.push(
withLocation(
exportTemplate({
LOCAL: t.identifier(e.local),
REMOTE: t.identifier('default'),
}),
e.loc,
),
);
},
);
state.exportAll.forEach(
(e: {file: string, loc: ?BabelSourceLocation, ...}) => {
body.push(
...withLocation(
exportAllTemplate({
FILE: resolvePath(
t.stringLiteral(e.file),
state.opts.resolve,
),
REQUIRED: path.scope.generateUidIdentifier(e.file),
KEY: path.scope.generateUidIdentifier('key'),
}),
e.loc,
),
);
},
);
state.exportNamed.forEach(
(e: {
local: string,
remote: string,
loc: ?BabelSourceLocation,
...
}) => {
body.push(
withLocation(
exportTemplate({
LOCAL: t.identifier(e.local),
REMOTE: t.identifier(e.remote),
}),
e.loc,
),
);
},
);
if (
state.exportDefault.length ||
state.exportAll.length ||
state.exportNamed.length
) {
body.unshift(esModuleExportTemplate());
if (state.opts.out) {
state.opts.out.isESModule = true;
}
} else if (state.opts.out) {
state.opts.out.isESModule = false;
}
},
},
},
};
}