/**
* Create the module export expression.
*
* @param {AstNode} exportedExpression - expression to export.
* @returns {AstNode} module exports node.
*/
function createExportStatement(exportedExpression) {
const exportsExpression = builders.memberExpression(
builders.identifier('module'), builders.identifier('exports'), false
);
const assignmentExpression = builders.assignmentExpression('=', exportsExpression, exportedExpression);
return builders.expressionStatement(assignmentExpression);
}
export function createRequireDeclaration(moduleIdentifier, importedModule) {
const requireCall = builders.callExpression(
builders.identifier('require'), [builders.literal(importedModule)]
);
if (moduleIdentifier) {
return builders.variableDeclaration(
'var', [builders.variableDeclarator(moduleIdentifier, requireCall)]
);
}
return requireCall;
}
fullyQualifiedNameData.forEach(({moduleVariableId, nodePathsToTransform}, namespace) => {
const moduleIdentifier = builders.identifier(moduleVariableId);
const importDeclaration = createRequireDeclaration(moduleIdentifier, namespace);
programStatements.unshift(importDeclaration);
nodePathsToTransform.forEach((nodePathToTransform) => nodePathToTransform.replace(moduleIdentifier));
});
handleErrorBlur(target, editor) {
const val = editor.getValue();
try {
const body =
parse(val).program.body[0] || types.builders.emptyStatement();
this.props.onChange(body);
} catch (e) {
// do nothing
}
}
/**
* Component
* @param {{code:Object[], onChange:(AST:Object[])=>void}} props Component's props
*/
function SingleStatement(props) {
const { code, onChange } = props;
const stmt = code[0] || types.builders.emptyStatement();
return (
<Comp
{...props}
node={stmt}
onChange={v => onChange([types.builders.expressionStatement(v)])}
/>
);
}
/**
* Retrieve the expression to export, if the module ends in a return statement export that node.
*
* @param {NodePath} lastStatement - Last statement in the module.
* @param {string} className - The class name to export.
* @returns {AstNode} node to export.
*/
function retrieveExportExpression(lastStatement, className) {
if (namedTypes.ReturnStatement.check(lastStatement.node)) {
const returnArgument = lastStatement.node.argument;
lastStatement.replace();
return returnArgument;
}
return builders.identifier(className);
}
function filterNonPathConfig(loaderConfig) {
var props = [];
astt.visit(loaderConfig, {
visitProperty: function (property) {
if (isNonPathProperty(property)) {
props.push(property.value);
}
return false; // only visit top-level properties
}
});
if (props.length > 1) {
props.sort(alphaPropertyKeys);
}
return astt.builders.objectExpression(props);
}
* SpiderMonkey AST node.
* https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Parser_API
*
* @typedef {Object} AstNode
* @property {string} type - A string representing the AST variant type.
*/
/**
* AstTypes NodePath.
*
* @typedef {Object} NodePath
* @property {AstNode} node - SpiderMonkey AST node.
*/
/**
*/
export const wrapModuleInIIFEVisitor = {
/**
* @param {NodePath} programNodePath - Program NodePath.
*/
visitProgram(programNodePath) {
const moduleBlockStatement = builders.blockStatement(programNodePath.node.body);
const iife = builders.functionExpression(null, [], moduleBlockStatement);
const iifeExpressionStatement = builders.expressionStatement(builders.callExpression(iife, []));
programNodePath.get('body').replace([iifeExpressionStatement]);
return false;
}
};
onChange={v => onChange([types.builders.expressionStatement(v)])}