khufu
Version:
A template language for incremental-dom or DSL for javascript views
276 lines (240 loc) • 10.8 kB
JavaScript
'use strict';
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.compile = compile;
var _babelTypes = require('babel-types');
var T = _interopRequireWildcard(_babelTypes);
var _compiler = require('./compiler');
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 GLOBAL_NAMES = new Set(['true', 'false', 'null']);
function compile(item, path, opt) {
switch (item[0]) {
case 'string':
{
var _item = _slicedToArray(item, 2),
_string = _item[0],
value = _item[1];
return T.stringLiteral(value);
}
case 'template':
{
var _item2 = _slicedToArray(item, 2),
_template = _item2[0],
items = _item2[1];
var quasis = [];
var exprs = [];
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _step$value = _slicedToArray(_step.value, 2),
kind = _step$value[0],
val = _step$value[1];
if (kind == 'const') {
quasis.push(T.templateElement({ raw: val }));
} else {
exprs.push(compile(val, path, opt));
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
quasis[quasis.length - 1].tail = true;
return T.templateLiteral(quasis, exprs);
}
case 'apply_template':
{
var _item3 = _slicedToArray(item, 3),
_apply_template = _item3[0],
expr = _item3[1],
_items = _item3[2];
var tag = compile(expr, path, opt);
var _quasis = [];
var _exprs = [];
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = _items[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _step2$value = _slicedToArray(_step2.value, 2),
kind = _step2$value[0],
val = _step2$value[1];
if (kind == 'const') {
_quasis.push(T.templateElement({ raw: val }));
} else {
_exprs.push(compile(val, path, opt));
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
_quasis[_quasis.length - 1].tail = true;
return T.taggedTemplateExpression(tag, T.templateLiteral(_quasis, _exprs));
}
case 'number':
{
var _item4 = _slicedToArray(item, 2),
_number = _item4[0],
_value = _item4[1];
return T.numericLiteral(Number(_value));
}
case 'list':
{
var _item5 = _slicedToArray(item, 2),
_list = _item5[0],
expressions = _item5[1];
return T.arrayExpression(expressions.map(function (x) {
return compile(x, path, opt);
}));
}
case 'object':
{
var _item6 = _slicedToArray(item, 2),
_object = _item6[0],
_expressions = _item6[1];
return T.objectExpression(_expressions.map(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2),
k = _ref2[0],
v = _ref2[1];
if (/[a-zA-Z_][a-zA_Z_0-9]*/.exec(k)) {
return T.objectProperty(T.identifier(k), compile(v, path, opt), false, true, null);
} else {
return T.objectProperty(T.stringLiteral(k), compile(v, path, opt), true, false, null);
}
}));
}
case 'name':
{
var _item7 = _slicedToArray(item, 2),
_name = _item7[0],
name = _item7[1];
if (GLOBAL_NAMES.has(name)) {
return T.identifier(name);
}
return (0, _vars.get_var)(path, name, item);
}
case 'store':
{
var _item8 = _slicedToArray(item, 2),
_store = _item8[0],
_name2 = _item8[1];
var store = (0, _vars.get_var)(path, _name2, item);
var state = path.scope.getData('khufu:store:state:' + _name2);
if (!state) {
state = path.scope.generateUidIdentifier(_name2 + '_state');
path.scope.push({
id: state,
init: T.callExpression(T.memberExpression(store, T.identifier('getState')), []),
kind: 'let'
});
path.scope.setData('khufu:store:state:' + _name2, state);
}
return state;
}
case 'raw_store':
{
var _item9 = _slicedToArray(item, 2),
_raw_store = _item9[0],
_name3 = _item9[1];
return (0, _vars.get_var)(path, _name3, item);
}
case 'attr':
{
var _item10 = _slicedToArray(item, 3),
_attr = _item10[0],
object = _item10[1],
_name4 = _item10[2];
return T.memberExpression(compile(object, path, opt), T.identifier(_name4));
}
case 'index':
{
var _item11 = _slicedToArray(item, 3),
_index = _item11[0],
_object2 = _item11[1],
key = _item11[2];
return T.memberExpression(compile(_object2, path, opt), compile(key, path, opt), true);
}
case 'call':
{
var _item12 = _slicedToArray(item, 3),
_call = _item12[0],
fun = _item12[1],
args = _item12[2];
return T.callExpression(compile(fun, path, opt), args.map(function (x) {
return compile(x, path, opt);
}));
}
case 'unary':
{
var _item13 = _slicedToArray(item, 3),
_unary = _item13[0],
op = _item13[1],
_value2 = _item13[2];
return T.unaryExpression(op, compile(_value2, path, opt));
}
case 'binop':
{
var _item14 = _slicedToArray(item, 4),
_binop = _item14[0],
oper = _item14[1],
left = _item14[2],
right = _item14[3];
return T.binaryExpression(oper, compile(left, path, opt), compile(right, path, opt));
}
case 'logop':
{
var _item15 = _slicedToArray(item, 4),
_logop = _item15[0],
_oper = _item15[1],
_left = _item15[2],
_right = _item15[3];
return T.logicalExpression(_oper, compile(_left, path, opt), compile(_right, path, opt));
}
case 'ternary':
{
var _item16 = _slicedToArray(item, 4),
_ternary = _item16[0],
cond = _item16[1],
positive = _item16[2],
negative = _item16[3];
return T.conditionalExpression(compile(cond, path, opt), compile(positive, path, opt), compile(negative, path, opt));
}
case 'if':
{
var _item17 = _slicedToArray(item, 4),
_if = _item17[0],
_cond = _item17[1],
norm = _item17[2],
alter = _item17[3];
return T.conditionalExpression(compile(_cond, path, opt), compile(norm, path, opt), compile(alter, path, opt));
}
default:
throw (0, _compiler.parse_tree_error)('Unknown expression', item);
}
}