385 lines
10 KiB
JavaScript
385 lines
10 KiB
JavaScript
module.exports = SystemFormatter;
|
|
|
|
var util = require("../../util");
|
|
var t = require("../../types");
|
|
var traverse = require("../../traverse");
|
|
var _ = require("lodash");
|
|
|
|
var SETTER_MODULE_NAMESPACE = t.identifier("m");
|
|
var PRIVATE_MODULE_NAME_IDENTIFIER = t.identifier("__moduleName");
|
|
var DEFAULT_IDENTIFIER = t.identifier("default");
|
|
var NULL_SETTER = t.literal(null);
|
|
|
|
function SystemFormatter(file) {
|
|
this.moduleNameLiteral = null;
|
|
this.exportedStatements = [];
|
|
this.moduleDependencies = {};
|
|
this.importedVariables = {};
|
|
|
|
this.exportIdentifier = file.generateUidIdentifier("export");
|
|
this.file = file;
|
|
|
|
/**
|
|
* @type Function
|
|
* @param {Array} args - The arguments of the "_export(...args)" function
|
|
* @return {Object} The expression statement with the call expression.
|
|
*/
|
|
this._makeExportStatements = _.compose(
|
|
t.expressionStatement,
|
|
// will generate the call expression : _export(...args)
|
|
_.partial(t.callExpression, this.exportIdentifier)
|
|
);
|
|
}
|
|
|
|
SystemFormatter.prototype.import =
|
|
SystemFormatter.prototype.export = function (node, nodes) {
|
|
nodes.push(node);
|
|
};
|
|
|
|
SystemFormatter.prototype.importSpecifier =
|
|
SystemFormatter.prototype.exportSpecifier = function (specifier, node, nodes) {
|
|
if (!nodes.length) nodes.push(node);
|
|
};
|
|
|
|
SystemFormatter.prototype.transform = function (ast) {
|
|
|
|
var systemTransform = this;
|
|
|
|
// extract the module name
|
|
this.moduleNameLiteral = t.literal(
|
|
this.file.opts.filename.replace(/^.*\//, "").replace(/\..*$/, "")
|
|
);
|
|
|
|
// Post extraction of the import/export declaration
|
|
traverse(ast, function (node) {
|
|
var replacementNode = null;
|
|
|
|
/**
|
|
* Process the current node with an extractor.
|
|
* @param {Function} extractor Extract the node data
|
|
* @returns {*} Can be a `node` (for replacement), void 0 (for removing)
|
|
* or false.
|
|
*/
|
|
function processTheNode(extractor) {
|
|
var result = extractor.call(systemTransform, node);
|
|
result = (result === void 0) ? [] : result;
|
|
replacementNode = result || replacementNode;
|
|
return !!replacementNode;
|
|
}
|
|
|
|
_.some([
|
|
// Import
|
|
SystemFormatter.prototype._extractImportSpecifiers,
|
|
SystemFormatter.prototype._extractImport,
|
|
|
|
// Export
|
|
SystemFormatter.prototype._extractExportDefault,
|
|
SystemFormatter.prototype._extractExportVariableDeclaration,
|
|
SystemFormatter.prototype._extractExportFunctionDeclaration,
|
|
SystemFormatter.prototype._extractExportSpecifiers
|
|
],
|
|
processTheNode
|
|
);
|
|
|
|
return replacementNode;
|
|
});
|
|
|
|
// Other
|
|
this._prependImportVariables(ast);
|
|
this._prependPrivateModuleName(ast);
|
|
this._appendModuleReturnStatement(ast);
|
|
this._wrapInSystemRegisterCallExpression(ast);
|
|
};
|
|
|
|
//
|
|
// Import extraction
|
|
//
|
|
|
|
SystemFormatter.prototype._extractImportSpecifiers = function (node) {
|
|
|
|
var systemTransform = this;
|
|
|
|
if (!(t.isImportDeclaration(node) && node.specifiers && node.specifiers.length )) {
|
|
return false;
|
|
}
|
|
|
|
_.each(node.specifiers, function (specifier) {
|
|
|
|
var variableName = t.getSpecifierName(specifier);
|
|
|
|
if (specifier.default) {
|
|
specifier.id = DEFAULT_IDENTIFIER;
|
|
}
|
|
|
|
var right = SETTER_MODULE_NAMESPACE;
|
|
if (!t.isImportBatchSpecifier(specifier)) {
|
|
right = t.memberExpression(right, specifier.id);
|
|
}
|
|
systemTransform.importedVariables[variableName.name] = true;
|
|
systemTransform._addImportStatement(node.source.value, t.expressionStatement(
|
|
t.assignmentExpression("=", variableName, right)
|
|
));
|
|
|
|
});
|
|
};
|
|
|
|
SystemFormatter.prototype._extractImport = function (node) {
|
|
if (!(t.isImportDeclaration(node))) {
|
|
return false;
|
|
}
|
|
|
|
this._addImportStatement(node.source.value);
|
|
};
|
|
|
|
//
|
|
// Export extraction
|
|
//
|
|
|
|
SystemFormatter.prototype._extractExportDefault = function (node) {
|
|
if (!(t.isExportDeclaration(node) && node.default)) {
|
|
return false;
|
|
}
|
|
|
|
var declar = node.declaration;
|
|
var variableName = DEFAULT_IDENTIFIER.name;
|
|
var returnNode;
|
|
|
|
if (t.isFunction(declar)) {
|
|
if (!declar.id) {
|
|
declar.id = this.file.generateUidIdentifier("anonymous");
|
|
}
|
|
returnNode = t.toStatement(declar);
|
|
declar = declar.id;
|
|
}
|
|
|
|
this._addToExportStatements(variableName, declar);
|
|
|
|
return returnNode;
|
|
};
|
|
|
|
SystemFormatter.prototype._extractExportVariableDeclaration = function (node) {
|
|
var systemTransform = this;
|
|
var declar = node.declaration;
|
|
|
|
if (!(t.isExportDeclaration(node) && t.isVariableDeclaration(declar))) {
|
|
return false;
|
|
}
|
|
|
|
function separateDeclarationAndInit(memo, varDeclar) {
|
|
memo.varDeclaration.push(_.omit(varDeclar, "init"));
|
|
systemTransform._addToExportStatements(varDeclar.id.name, varDeclar);
|
|
return memo;
|
|
}
|
|
|
|
var declarationSeparation = _.reduce(
|
|
declar.declarations,
|
|
separateDeclarationAndInit,
|
|
{ varDeclaration: [], varInitialization: [] }
|
|
);
|
|
|
|
return _.assign(declar, { declarations: declarationSeparation.varDeclaration });
|
|
};
|
|
|
|
SystemFormatter.prototype._extractExportFunctionDeclaration = function (node) {
|
|
var declar = node.declaration;
|
|
|
|
if (!(t.isExportDeclaration(node) && t.isFunctionDeclaration(declar))) {
|
|
return false;
|
|
}
|
|
this._addToExportStatements(declar.id.name, declar.id);
|
|
return declar;
|
|
|
|
};
|
|
|
|
SystemFormatter.prototype._extractExportSpecifiers = function (node) {
|
|
var systemTransform = this;
|
|
|
|
if (!( t.isExportDeclaration(node) && node.specifiers )) {
|
|
return false;
|
|
}
|
|
|
|
_.each(node.specifiers, function (specifier) {
|
|
|
|
// Run each, break when one is true.
|
|
_.some([
|
|
SystemFormatter.prototype._extractExportBatch,
|
|
SystemFormatter.prototype._extractExportFrom,
|
|
SystemFormatter.prototype._extractExportNamed
|
|
], function (extractor) {
|
|
var result = extractor.call(systemTransform, specifier, node);
|
|
return result === void 0 || result;
|
|
});
|
|
|
|
});
|
|
|
|
// Note: here we don't care about the node replacement.
|
|
// The current node will always be removed.
|
|
// So no return.
|
|
};
|
|
|
|
SystemFormatter.prototype._extractExportBatch = function (specifier, node) {
|
|
|
|
if (!(node.source && t.isExportBatchSpecifier(specifier))) {
|
|
return false;
|
|
}
|
|
|
|
var exportBatch = this._makeExportWildcard(SETTER_MODULE_NAMESPACE);
|
|
this._addImportStatement(node.source.value, exportBatch);
|
|
};
|
|
|
|
SystemFormatter.prototype._extractExportFrom = function (specifier, node) {
|
|
|
|
// Weak test here...
|
|
if (!(node.source)) {
|
|
return false;
|
|
}
|
|
|
|
var variableName = t.getSpecifierName(specifier);
|
|
|
|
var target = t.memberExpression(
|
|
SETTER_MODULE_NAMESPACE,
|
|
specifier.id
|
|
);
|
|
|
|
var exportSelection = this._makeExportStatements([
|
|
t.literal(variableName.name), target
|
|
]);
|
|
|
|
this._addImportStatement(node.source.value, exportSelection);
|
|
};
|
|
|
|
SystemFormatter.prototype._extractExportNamed = function (specifier) {
|
|
|
|
// Last case...
|
|
// Dunno what to test here...
|
|
|
|
var variableName = t.getSpecifierName(specifier);
|
|
this._addToExportStatements(variableName.name, specifier.id);
|
|
};
|
|
|
|
//
|
|
// Utils collection handler
|
|
//
|
|
|
|
SystemFormatter.prototype._addToExportStatements = function (name, identifier) {
|
|
this.exportedStatements.push(
|
|
this._makeExportStatements([t.literal(name), identifier])
|
|
);
|
|
};
|
|
|
|
/**
|
|
* Generate a export wildcard expression
|
|
* /!\ this is a hack over the existing "exports-wildcard" template
|
|
* @param objectIdentifier
|
|
* @returns the export wildcard expression
|
|
* @private
|
|
*/
|
|
SystemFormatter.prototype._makeExportWildcard = function (objectIdentifier) {
|
|
|
|
var exportStatement = util.template("exports-wildcard", {
|
|
OBJECT: objectIdentifier
|
|
}, true);
|
|
|
|
delete exportStatement.expression.callee.expression._scopeReferences;
|
|
|
|
var forStatement = exportStatement.expression.callee.expression.body.body[0];
|
|
var iteratorIdentifier = forStatement.left.declarations[0].id;
|
|
var target = t.memberExpression(
|
|
forStatement.right,
|
|
iteratorIdentifier,
|
|
true
|
|
);
|
|
|
|
forStatement.body.body = [
|
|
this._makeExportStatements([iteratorIdentifier, target])
|
|
];
|
|
|
|
return exportStatement;
|
|
};
|
|
|
|
SystemFormatter.prototype._addImportStatement = function (name, importStatement) {
|
|
this.moduleDependencies[name] = this.moduleDependencies[name] || [];
|
|
importStatement && this.moduleDependencies[name].push(importStatement);
|
|
};
|
|
|
|
//
|
|
// Additional body content
|
|
//
|
|
|
|
SystemFormatter.prototype._prependImportVariables = function (ast) {
|
|
|
|
var declaredSetters = _(this.importedVariables).keys().map(function (name) {
|
|
return _.compose(t.variableDeclarator, t.identifier)(name);
|
|
}
|
|
).value();
|
|
|
|
if (declaredSetters.length) {
|
|
ast.program.body.splice(1, 0, t.variableDeclaration("var", declaredSetters));
|
|
}
|
|
};
|
|
|
|
SystemFormatter.prototype._prependPrivateModuleName = function (ast) {
|
|
// generate the __moduleName variable
|
|
var moduleNameVariableNode = t.variableDeclaration("var", [
|
|
t.variableDeclarator(
|
|
PRIVATE_MODULE_NAME_IDENTIFIER,
|
|
this.moduleNameLiteral
|
|
)
|
|
]);
|
|
|
|
ast.program.body.splice(1, 0, moduleNameVariableNode);
|
|
};
|
|
|
|
SystemFormatter.prototype._buildSetters = function () {
|
|
// generate setters array expression elements
|
|
return _.map(this.moduleDependencies, function (specs) {
|
|
if (!specs.length) {
|
|
return NULL_SETTER;
|
|
}
|
|
|
|
return t.functionExpression(
|
|
null, [SETTER_MODULE_NAMESPACE], t.blockStatement(specs)
|
|
);
|
|
});
|
|
};
|
|
|
|
SystemFormatter.prototype._appendModuleReturnStatement = function (ast) {
|
|
|
|
// generate the execute function expression
|
|
var executeFunctionExpression = t.functionExpression(
|
|
null, [], t.blockStatement(this.exportedStatements)
|
|
);
|
|
|
|
// generate the execute function expression
|
|
var settersArrayExpression = t.arrayExpression(this._buildSetters());
|
|
|
|
// generate the return statement
|
|
var moduleReturnStatement = t.returnStatement(t.objectExpression([
|
|
t.property("init", t.identifier("setters"), settersArrayExpression),
|
|
t.property("init", t.identifier("execute"), executeFunctionExpression)
|
|
]));
|
|
|
|
ast.program.body.push(moduleReturnStatement);
|
|
};
|
|
|
|
SystemFormatter.prototype._wrapInSystemRegisterCallExpression = function (ast) {
|
|
var program = ast.program;
|
|
var body = program.body;
|
|
|
|
var moduleDependencyNames = Object
|
|
.keys(this.moduleDependencies)
|
|
.map(t.literal);
|
|
|
|
var runner = util.template("register", {
|
|
MODULE_NAME: this.moduleNameLiteral,
|
|
MODULE_DEPENDENCIES: t.arrayExpression(moduleDependencyNames),
|
|
MODULE_BODY: t.functionExpression(
|
|
null,
|
|
[this.exportIdentifier],
|
|
t.blockStatement(body)
|
|
)
|
|
});
|
|
|
|
program.body = [t.expressionStatement(runner)];
|
|
};
|