@glimmer/compiler/dist/modules/es5/lib/template-compiler.js

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

import TemplateVisitor from './template-visitor';
import JavaScriptCompiler from './javascript-compiler';
import { assert } from '@glimmer/util';
import { isLiteral, SyntaxError } from '@glimmer/syntax';
import { getAttrNamespace } from './utils';
import { SymbolAllocator } from './allocate-symbols';

import { locationToOffset } from './location';
function isTrustedValue(value) {
    return value.escaped !== undefined && !value.escaped;
}
export var THIS = 0;

var TemplateCompiler = function () {
    function TemplateCompiler(source) {
        _classCallCheck(this, TemplateCompiler);

        this.source = source;
        this.templateId = 0;
        this.templateIds = [];
        this.opcodes = [];
        this.locations = [];
        this.includeMeta = true;
    }

    TemplateCompiler.compile = function compile(ast, source, options) {
        var templateVisitor = new TemplateVisitor();
        templateVisitor.visit(ast);
        var compiler = new TemplateCompiler(source);

        var _compiler$process = compiler.process(templateVisitor.actions),
            opcodes = _compiler$process.opcodes,
            templateLocations = _compiler$process.locations;

        var _process = new SymbolAllocator(opcodes, templateLocations).process(),
            ops = _process.ops,
            allocationLocations = _process.locations;

        var out = JavaScriptCompiler.process(ops, allocationLocations, ast.symbols, options);
        if (false) {
            console.log('Template ->', out);
        }
        return out;
    };

    TemplateCompiler.prototype.process = function process(actions) {
        var _this = this;

        actions.forEach(function (_ref) {
            var name = _ref[0],
                args = _ref[1];

            if (!_this[name]) {
                throw new Error('Unimplemented ' + name + ' on TemplateCompiler');
            }
            _this[name](args);
        });
        return { opcodes: this.opcodes, locations: this.locations };
    };

    TemplateCompiler.prototype.startProgram = function startProgram(_ref2) {
        var program = _ref2[0];

        this.opcode(['startProgram', program], program);
    };

    TemplateCompiler.prototype.endProgram = function endProgram() {
        this.opcode(['endProgram'], null);
    };

    TemplateCompiler.prototype.startBlock = function startBlock(_ref3) {
        var program = _ref3[0];

        this.templateId++;
        this.opcode(['startBlock', program], program);
    };

    TemplateCompiler.prototype.endBlock = function endBlock() {
        this.templateIds.push(this.templateId - 1);
        this.opcode(['endBlock'], null);
    };

    TemplateCompiler.prototype.text = function text(_ref4) {
        var action = _ref4[0];

        this.opcode(['text', action.chars], action);
    };

    TemplateCompiler.prototype.comment = function comment(_ref5) {
        var action = _ref5[0];

        this.opcode(['comment', action.value], action);
    };

    TemplateCompiler.prototype.openElement = function openElement(_ref6) {
        var action = _ref6[0];

        var attributes = action.attributes;
        var simple = true;
        for (var i = 0; i < attributes.length; i++) {
            var attr = attributes[i];
            if (attr.name === '...attributes') {
                simple = false;
                break;
            }
        }
        if (action.modifiers.length > 0) {
            simple = false;
        }
        var actionIsComponent = false;
        var dynamic = destructureDynamicComponent(action);
        if (dynamic) {
            this.expression(dynamic, "ComponentHead" /* ComponentHead */, action);
            this.opcode(['openComponent', action], action);
            actionIsComponent = true;
        } else if (isNamedBlock(action)) {
            this.opcode(['openNamedBlock', action], action);
        } else if (isComponent(action)) {
            this.opcode(['openComponent', action], action);
            actionIsComponent = true;
        } else {
            this.opcode(['openElement', [action, simple]], action);
        }
        if (!isNamedBlock(action)) {
            // TODO: Assert no attributes
            var typeAttr = null;
            var attrs = action.attributes;
            for (var _i = 0; _i < attrs.length; _i++) {
                if (attrs[_i].name === 'type') {
                    typeAttr = attrs[_i];
                    continue;
                }
                this.attribute([attrs[_i]], !simple || actionIsComponent);
            }
            if (typeAttr) {
                this.attribute([typeAttr], !simple || actionIsComponent);
            }
            for (var _i2 = 0; _i2 < action.modifiers.length; _i2++) {
                this.modifier([action.modifiers[_i2]]);
            }
            this.opcode(['flushElement', action], null);
        }
    };

    TemplateCompiler.prototype.closeElement = function closeElement(_ref7) {
        var action = _ref7[0];

        if (isNamedBlock(action)) {
            this.opcode(['closeNamedBlock', action]);
        } else if (destructureDynamicComponent(action)) {
            this.opcode(['closeDynamicComponent', action], action);
        } else if (isComponent(action)) {
            this.opcode(['closeComponent', action], action);
        } else {
            this.opcode(['closeElement', action], action);
        }
    };

    TemplateCompiler.prototype.attribute = function attribute(_ref8, isComponent) {
        var action = _ref8[0];
        var name = action.name,
            value = action.value;

        var namespace = getAttrNamespace(name);
        var isStatic = this.prepareAttributeValue(value);
        if (name.charAt(0) === '@') {
            // Arguments
            if (isStatic) {
                this.opcode(['staticArg', name], action);
            } else if (action.value.type === 'MustacheStatement') {
                this.opcode(['dynamicArg', name], action);
            } else {
                this.opcode(['dynamicArg', name], action);
            }
        } else {
            var isTrusting = isTrustedValue(value);
            if (isStatic && name === '...attributes') {
                this.opcode(['attrSplat'], action);
            } else if (isStatic && !isComponent) {
                this.opcode(['staticAttr', [name, namespace]], action);
            } else if (isTrusting) {
                this.opcode(isComponent ? ['trustingComponentAttr', [name, namespace]] : ['trustingAttr', [name, namespace]], action);
            } else if (action.value.type === 'MustacheStatement') {
                this.opcode(isComponent ? ['componentAttr', [name, namespace]] : ['dynamicAttr', [name, namespace]], action);
            } else {
                this.opcode(isComponent ? ['componentAttr', [name, namespace]] : ['dynamicAttr', [name, namespace]], action);
            }
        }
    };

    TemplateCompiler.prototype.modifier = function modifier(_ref9) {
        var action = _ref9[0];

        this.prepareHelper(action, 'modifier');
        this.expression(action.path, "ModifierHead" /* ModifierHead */, action);
        this.opcode(['modifier'], action);
    };

    TemplateCompiler.prototype.mustache = function mustache(_ref10) {
        var _mustache = _ref10[0];
        var path = _mustache.path;

        if (isLiteral(path)) {
            this.expression(_mustache.path, "Expression" /* Expression */, _mustache);
            this.opcode(['append', !_mustache.escaped], _mustache);
        } else if (path.type !== 'PathExpression') {
            throw new SyntaxError('Expected PathExpression, got ' + path.type, path.loc);
        } else if (isYield(path)) {
            var to = assertValidYield(_mustache);
            this.yield(to, _mustache);
        } else if (isPartial(path)) {
            var params = assertValidPartial(_mustache);
            this.partial(params, _mustache);
        } else if (isDebugger(path)) {
            assertValidDebuggerUsage(_mustache);
            this.debugger('debugger', _mustache);
        } else if (isKeyword(_mustache)) {
            this.keyword(_mustache);
            this.opcode(['append', !_mustache.escaped], _mustache);
        } else if (isHelperInvocation(_mustache)) {
            this.prepareHelper(_mustache, 'helper');
            this.expression(_mustache.path, "CallHead" /* CallHead */, _mustache.path);
            this.opcode(['helper'], _mustache);
            this.opcode(['append', !_mustache.escaped], _mustache);
        } else {
            this.expression(_mustache.path, mustacheContext(_mustache.path), _mustache);
            this.opcode(['append', !_mustache.escaped], _mustache);
        }
    };

    TemplateCompiler.prototype.block = function block(_ref11) {
        var action /*, index, count*/ = _ref11[0];

        this.prepareHelper(action, 'block');
        var templateId = this.templateIds.pop();
        var inverseId = action.inverse === null ? null : this.templateIds.pop();
        this.expression(action.path, "BlockHead" /* BlockHead */, action);
        this.opcode(['block', [templateId, inverseId]], action);
    };
    /// Internal actions, not found in the original processed actions
    // private path(head: string, rest: string[], context: ExpressionContext, loc: AST.BaseNode) {
    //   if (head[0] === '@') {
    //     this.argPath(head, rest, loc);
    //   } else {
    //     this.varPath(head, rest, context, loc);
    //   }
    // }


    TemplateCompiler.prototype.argPath = function argPath(head, rest, loc) {
        this.opcode(['getArg', head], loc);
        this.opcode(['getPath', rest], loc);
    };

    TemplateCompiler.prototype.varPath = function varPath(head, rest, context, loc) {
        this.opcode(['getVar', [head, context]], loc);
        this.opcode(['getPath', rest], loc);
    };

    TemplateCompiler.prototype.thisPath = function thisPath(rest, loc) {
        this.opcode(['getThis'], loc);
        this.opcode(['getPath', rest], loc);
    };

    TemplateCompiler.prototype.expression = function expression(path, context, expr) {
        if (isLiteral(path)) {
            this.opcode(['literal', path.value], expr);
        } else if (path.type !== 'PathExpression') {
            throw new SyntaxError('Expected PathExpression, got ' + path.type, path.loc);
        } else if (isKeyword(expr)) {
            this.keyword(expr);
        } else {
            this.path(path, context);
        }
    };
    /// Internal Syntax


    TemplateCompiler.prototype.yield = function _yield(to, action) {
        this.prepareParams(action.params);
        this.opcode(['yield', to], action);
    };

    TemplateCompiler.prototype.debugger = function _debugger(_name, action) {
        this.opcode(['debugger', null], action);
    };

    TemplateCompiler.prototype.hasBlock = function hasBlock(name, action) {
        this.opcode(['hasBlock', name], action);
    };

    TemplateCompiler.prototype.hasBlockParams = function hasBlockParams(name, action) {
        this.opcode(['hasBlockParams', name], action);
    };

    TemplateCompiler.prototype.partial = function partial(_params, action) {
        this.prepareParams(action.params);
        this.opcode(['partial'], action);
    };

    TemplateCompiler.prototype.keyword = function keyword(action) {
        var path = action.path;

        if (isHasBlock(path)) {
            var name = assertValidHasBlockUsage(path.original, action);
            this.hasBlock(name, action);
        } else if (isHasBlockParams(path)) {
            var _name2 = assertValidHasBlockUsage(path.original, action);
            this.hasBlockParams(_name2, action);
        }
    };
    /// Expressions, invoked recursively from prepareParams and prepareHash


    TemplateCompiler.prototype.SubExpression = function SubExpression(expr) {
        if (isKeyword(expr)) {
            this.keyword(expr);
        } else {
            this.prepareHelper(expr, 'helper');
            this.expression(expr.path, "CallHead" /* CallHead */, expr);
            this.opcode(['helper']);
        }
    };

    TemplateCompiler.prototype.PathExpression = function PathExpression(expr) {
        this.path(expr, "Expression" /* Expression */);
    };

    TemplateCompiler.prototype.path = function path(expr, context) {
        var _expr$parts = expr.parts,
            head = _expr$parts[0],
            rest = _expr$parts.slice(1);

        if (expr.data) {
            this.argPath('@' + head, rest, expr);
        } else if (expr.this) {
            this.thisPath(expr.parts, expr);
        } else {
            this.varPath(head, rest, context, expr);
        }
    };

    TemplateCompiler.prototype.StringLiteral = function StringLiteral(action) {
        this.opcode(['literal', action.value], action);
    };

    TemplateCompiler.prototype.BooleanLiteral = function BooleanLiteral(action) {
        this.opcode(['literal', action.value], action);
    };

    TemplateCompiler.prototype.NumberLiteral = function NumberLiteral(action) {
        this.opcode(['literal', action.value], action);
    };

    TemplateCompiler.prototype.NullLiteral = function NullLiteral(action) {
        this.opcode(['literal', action.value], action);
    };

    TemplateCompiler.prototype.UndefinedLiteral = function UndefinedLiteral(action) {
        this.opcode(['literal', action.value], action);
    };
    /// Utilities


    TemplateCompiler.prototype.opcode = function opcode(_opcode) {
        var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

        if (action) {
            this.locations.push(this.location(action));
        } else {
            this.locations.push(null);
        }
        if (this.includeMeta && action) {
            _opcode.push(this.meta(action));
        }
        this.opcodes.push(_opcode);
    };

    TemplateCompiler.prototype.helperCall = function helperCall(call, node) {
        this.prepareHelper(call, 'helper');
        this.expression(call.path, "CallHead" /* CallHead */, node);
        this.opcode(['helper'], node);
    };

    TemplateCompiler.prototype.mustacheCall = function mustacheCall(call) {
        this.prepareHelper(call, 'helper');
        this.expression(call.path, "CallHead" /* CallHead */, call);
        this.opcode(['helper'], call);
    };

    TemplateCompiler.prototype.prepareHelper = function prepareHelper(expr, context) {
        assertIsSimplePath(expr.path, expr.loc, context);
        var params = expr.params,
            hash = expr.hash;

        this.prepareHash(hash);
        this.prepareParams(params);
    };

    TemplateCompiler.prototype.prepareParams = function prepareParams(params) {
        if (!params.length) {
            this.opcode(['literal', null], null);
            return;
        }
        for (var i = params.length - 1; i >= 0; i--) {
            var param = params[i];
            false && assert(this[param.type], 'Unimplemented ' + param.type + ' on TemplateCompiler');

            this[param.type](param);
        }
        this.opcode(['prepareArray', params.length], null);
    };

    TemplateCompiler.prototype.prepareHash = function prepareHash(hash) {
        var pairs = hash.pairs;
        if (!pairs.length) {
            this.opcode(['literal', null], null);
            return;
        }
        for (var i = pairs.length - 1; i >= 0; i--) {
            var _pairs$i = pairs[i],
                key = _pairs$i.key,
                value = _pairs$i.value;

            false && assert(this[value.type], 'Unimplemented ' + value.type + ' on TemplateCompiler');

            this[value.type](value);
            this.opcode(['literal', key], null);
        }
        this.opcode(['prepareObject', pairs.length], null);
    };

    TemplateCompiler.prototype.prepareAttributeValue = function prepareAttributeValue(value) {
        // returns the static value if the value is static
        if (value.type === 'ConcatStatement') {
            this.prepareConcatParts(value.parts);
            this.opcode(['concat'], value);
            return false;
        } else {
            return this.mustacheAttrValue(value);
        }
    };

    TemplateCompiler.prototype.prepareConcatParts = function prepareConcatParts(parts) {
        for (var i = parts.length - 1; i >= 0; i--) {
            var part = parts[i];
            this.mustacheAttrValue(part);
        }
        this.opcode(['prepareArray', parts.length], null);
    };

    TemplateCompiler.prototype.mustacheAttrValue = function mustacheAttrValue(value) {
        if (value.type === 'TextNode') {
            this.opcode(['literal', value.chars]);
            return true;
        } else if (isKeyword(value)) {
            this.keyword(value);
        } else if (isHelperInvocation(value)) {
            this.prepareHelper(value, 'helper');
            this.expression(value.path, "CallHead" /* CallHead */, value);
            this.opcode(['helper'], value);
        } else {
            this.expression(value.path, "AppendSingleId" /* AppendSingleId */, value);
        }
        return false;
    };

    TemplateCompiler.prototype.meta = function meta(node) {
        var loc = node.loc;
        if (!loc) {
            return [];
        }
        var source = loc.source,
            start = loc.start,
            end = loc.end;

        return ['loc', [source || null, [start.line, start.column], [end.line, end.column]]];
    };

    TemplateCompiler.prototype.location = function location(node) {
        var loc = node.loc;
        if (!loc) return null;
        var source = loc.source,
            start = loc.start,
            end = loc.end;

        var startOffset = locationToOffset(this.source, start.line - 1, start.column);
        var endOffset = locationToOffset(this.source, end.line - 1, end.column);
        if (startOffset === null || endOffset === null) {
            // Should this be an assertion?
            return null;
        }
        return {
            source: source || null,
            start: startOffset,
            end: endOffset
        };
    };

    return TemplateCompiler;
}();

export default TemplateCompiler;

function isHelperInvocation(mustache) {
    if (mustache.type !== 'SubExpression' && mustache.type !== 'MustacheStatement') {
        return false;
    }
    return mustache.params && mustache.params.length > 0 || mustache.hash && mustache.hash.pairs.length > 0;
}
function isSimplePath(_ref12) {
    var parts = _ref12.parts;

    return parts.length === 1;
}
function isYield(path) {
    return path.original === 'yield';
}
function isPartial(path) {
    return path.original === 'partial';
}
function isDebugger(path) {
    return path.original === 'debugger';
}
function isHasBlock(path) {
    if (path.type !== 'PathExpression') return false;
    return path.original === 'has-block';
}
function isHasBlockParams(path) {
    if (path.type !== 'PathExpression') return false;
    return path.original === 'has-block-params';
}
function isKeyword(node) {
    if (isCall(node)) {
        return isHasBlock(node.path) || isHasBlockParams(node.path);
    } else if (isPath(node)) {
        return isHasBlock(node) || isHasBlockParams(node);
    } else {
        return false;
    }
}
function isCall(node) {
    return node.type === 'SubExpression' || node.type === 'MustacheStatement';
}
function isPath(node) {
    return node.type === 'PathExpression';
}
function destructureDynamicComponent(element) {
    var open = element.tag.charAt(0);

    var _element$tag$split = element.tag.split('.'),
        maybeLocal = _element$tag$split[0],
        rest = _element$tag$split.slice(1);

    var isNamedArgument = open === '@';
    var isLocal = element.symbols.has(maybeLocal);
    var isThisPath = maybeLocal === 'this';
    if (isLocal) {
        return {
            type: 'PathExpression',
            data: false,
            parts: [maybeLocal].concat(rest),
            this: false,
            original: element.tag,
            loc: element.loc
        };
    } else if (isNamedArgument) {
        return {
            type: 'PathExpression',
            data: true,
            parts: [maybeLocal.slice(1)].concat(rest),
            this: false,
            original: element.tag,
            loc: element.loc
        };
    } else if (isThisPath) {
        return {
            type: 'PathExpression',
            data: false,
            parts: rest,
            this: true,
            original: element.tag,
            loc: element.loc
        };
    } else {
        return null;
    }
}
function isComponent(element) {
    var open = element.tag.charAt(0);
    var isPath = element.tag.indexOf('.') > -1;
    var isUpperCase = open === open.toUpperCase() && open !== open.toLowerCase();
    return isUpperCase && !isPath || !!destructureDynamicComponent(element);
}
function isNamedBlock(element) {
    var open = element.tag.charAt(0);
    return open === ':';
}
function assertIsSimplePath(path, loc, context) {
    if (path.type !== 'PathExpression') {
        throw new SyntaxError('`' + path.type + '` is not a valid ' + context + ' on line ' + loc.start.line + '.', path.loc);
    }
    if (!isSimplePath(path)) {
        throw new SyntaxError('`' + path.original + '` is not a valid name for a ' + context + ' on line ' + loc.start.line + '.', path.loc);
    }
}
function assertValidYield(statement) {
    var pairs = statement.hash.pairs;

    if (pairs.length === 1 && pairs[0].key !== 'to' || pairs.length > 1) {
        throw new SyntaxError('yield only takes a single named argument: \'to\'', statement.loc);
    } else if (pairs.length === 1 && pairs[0].value.type !== 'StringLiteral') {
        throw new SyntaxError('you can only yield to a literal value', statement.loc);
    } else if (pairs.length === 0) {
        return 'default';
    } else {
        return pairs[0].value.value;
    }
}
function assertValidPartial(statement) {
    var params = statement.params,
        hash = statement.hash,
        escaped = statement.escaped,
        loc = statement.loc;

    if (params && params.length !== 1) {
        throw new SyntaxError('Partial found with no arguments. You must specify a template name. (on line ' + loc.start.line + ')', statement.loc);
    } else if (hash && hash.pairs.length > 0) {
        throw new SyntaxError('partial does not take any named arguments (on line ' + loc.start.line + ')', statement.loc);
    } else if (!escaped) {
        throw new SyntaxError('{{{partial ...}}} is not supported, please use {{partial ...}} instead (on line ' + loc.start.line + ')', statement.loc);
    }
    return params;
}
function assertValidHasBlockUsage(type, call) {
    var params = call.params,
        hash = call.hash,
        loc = call.loc;

    if (hash && hash.pairs.length > 0) {
        throw new SyntaxError(type + ' does not take any named arguments', call.loc);
    }
    if (params.length === 0) {
        return 'default';
    } else if (params.length === 1) {
        var param = params[0];
        if (param.type === 'StringLiteral') {
            return param.value;
        } else {
            throw new SyntaxError('you can only yield to a literal value (on line ' + loc.start.line + ')', call.loc);
        }
    } else {
        throw new SyntaxError(type + ' only takes a single positional argument (on line ' + loc.start.line + ')', call.loc);
    }
}
function assertValidDebuggerUsage(statement) {
    var params = statement.params,
        hash = statement.hash;

    if (hash && hash.pairs.length > 0) {
        throw new SyntaxError('debugger does not take any named arguments', statement.loc);
    }
    if (params.length === 0) {
        return 'default';
    } else {
        throw new SyntaxError('debugger does not take any positional arguments', statement.loc);
    }
}
function mustacheContext(body) {
    if (body.type === 'PathExpression') {
        if (body.parts.length > 1 || body.data) {
            return "Expression" /* Expression */;
        } else {
                return "AppendSingleId" /* AppendSingleId */;
            }
    } else {
            return "Expression" /* Expression */;
        }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../packages/@glimmer/compiler/lib/template-compiler.ts"],"names":[],"mappings":"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","sourcesContent":["import TemplateVisitor, { Action } from './template-visitor';\nimport JavaScriptCompiler, { Template } from './javascript-compiler';\nimport { assert, Option } from '@glimmer/util';\nimport { AST, isLiteral, SyntaxError } from '@glimmer/syntax';\nimport { getAttrNamespace } from './utils';\nimport { SymbolAllocator } from './allocate-symbols';\nimport { Processor, InputOps, AllocateSymbolsOps, Ops, SourceLocation } from './compiler-ops';\nimport { DEBUG } from '@glimmer/local-debug-flags';\nimport { ExpressionContext } from '@glimmer/interfaces';\nimport { locationToOffset } from './location';\n\nexport interface CompileOptions {\n  meta?: unknown;\n  customizeComponentName?(tag: string): string;\n}\n\nfunction is