khufu
Version:
A template language for incremental-dom or DSL for javascript views
194 lines (164 loc) • 7.72 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
exports.parse_tree_error = parse_tree_error;
exports.compile = compile;
exports.compile_text = compile_text;
require('babel-polyfill');
var _babelCore = require('babel-core');
var babel = _interopRequireWildcard(_babelCore);
var _babelTypes = require('babel-types');
var T = _interopRequireWildcard(_babelTypes);
var _grammar = require('./grammar');
var _compile_view = require('./compile_view');
var view = _interopRequireWildcard(_compile_view);
var _compile_style = require('./compile_style');
var style = _interopRequireWildcard(_compile_style);
var _vars = require('./vars');
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
var DEFAULT_OPTIONS = {
static_attrs: true,
additional_class: function additional_class(wpack) {
// by default it's `b-${basename}` if in webpack
if (wpack) {
var items = wpack.resourcePath.split('/');
var blockname = items[items.length - 1].split('.')[0];
if (blockname) {
return 'b-' + blockname;
}
}
}
};
function parse_tree_error(message, tree) {
var strtree = tree.toString();
if (strtree.length > 20) {
strtree = strtree.substr(0, 17) + '...';
}
var loc = tree._location;
return Error(message + ' at ' + (loc ? loc.first_line + ':' + loc.first_column : 'unknown') + ' (' + strtree + ')');
}
function compile_block(block, path, opt) {
switch (block[0]) {
case 'view':
return view.compile(block, path, opt);
case 'style':
return style.compile(block, path, opt);
case 'import_names':
{
var _block2 = _slicedToArray(block, 3),
_import = _block2[0],
original_names = _block2[1],
module = _block2[2];
var names = original_names.map(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2),
name = _ref2[0],
alias = _ref2[1];
var real_alias = alias;
if (alias.substr(0, 1) == '@') {
real_alias = alias.substr(1);
}
if (view.BUILTINS.indexOf(real_alias) >= 0) {
real_alias = path.scope.generateUidIdentifier(real_alias);
} else {
real_alias = T.identifier(real_alias);
}
return [name, alias, real_alias];
});
path.pushContainer("body", T.importDeclaration(names.map(function (_ref3) {
var _ref4 = _slicedToArray(_ref3, 3),
n = _ref4[0],
a = _ref4[1],
r = _ref4[2];
if (n.substr(0, 1) == '@') {
return T.importSpecifier(r, T.identifier(n.substr(1)));
} else {
return T.importSpecifier(r, T.identifier(n));
}
}), T.stringLiteral(module)));
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = names[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _step$value = _slicedToArray(_step.value, 3),
name = _step$value[0],
alias = _step$value[1],
real_alias = _step$value[2];
if (name.substr(0, 1) == '@') {
(0, _vars.set_var)(path, alias.substr(1), real_alias);
} else {
(0, _vars.set_var)(path, alias, real_alias);
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return;
}
case 'import_default':
{
var _block3 = _slicedToArray(block, 3),
_import2 = _block3[0],
_name = _block3[1],
_module = _block3[2];
path.pushContainer("body", T.importDeclaration([T.importDefaultSpecifier(T.identifier(_name))], T.stringLiteral(_module)));
(0, _vars.set_var)(path, _name, T.identifier(_name));
return;
}
case 'import_namespace':
{
var _block4 = _slicedToArray(block, 3),
_import3 = _block4[0],
_name2 = _block4[1],
_module2 = _block4[2];
path.pushContainer("body", T.importDeclaration([T.importNamespaceSpecifier(T.identifier(_name2))], T.stringLiteral(_module2)));
(0, _vars.set_var)(path, _name2, T.identifier(_name2));
return;
}
default:
throw parse_tree_error("Unknown block", block);
}
}
function compile(txt, options, wpack) {
var opt = Object.assign({}, DEFAULT_OPTIONS, options);
if (typeof opt.additional_class == 'function') {
opt.additional_class = opt.additional_class(wpack);
}
opt.always_add_class = new Set(opt.always_add_class || []);
var parse_tree = _grammar.parser.parse(txt, opt);
var ast = T.file(T.program([]));
babel.traverse(ast, {
Program: function Program(path) {
parse_tree.filter(function (block) {
return block[0] == 'view';
}).map(function (_ref5) {
var _ref6 = _slicedToArray(_ref5, 2),
_block = _ref6[0],
name = _ref6[1];
// Bind all views in scope, so they can call each other
// (including recursively)
(0, _vars.set_var)(path, name, T.identifier(name));
});
parse_tree.map(function (block) {
return compile_block(block, path, opt);
});
}
});
return ast;
}
function compile_text(txt, options, wpack) {
return babel.transformFromAst(compile(txt, options, wpack)).code;
}