@glimmer/syntax
Version:
609 lines (504 loc) • 60.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.HandlebarsNodeVisitors = void 0;
var _parser = require("../parser");
var _location = require("../source/location");
var _syntaxError = require("../syntax-error");
var _utils = require("../utils");
var _legacyInterop = require("../v1/legacy-interop");
var _parserBuilders = _interopRequireDefault(require("../v1/parser-builders"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
subClass.__proto__ = superClass;
}
var HandlebarsNodeVisitors = /*#__PURE__*/function (_Parser) {
_inheritsLoose(HandlebarsNodeVisitors, _Parser);
function HandlebarsNodeVisitors() {
return _Parser.apply(this, arguments) || this;
}
var _proto = HandlebarsNodeVisitors.prototype;
_proto.Program = function Program(program) {
var body = [];
var node;
if (this.isTopLevel) {
node = _parserBuilders.default.template({
body: body,
blockParams: program.blockParams,
loc: this.source.spanFor(program.loc)
});
} else {
node = _parserBuilders.default.blockItself({
body: body,
blockParams: program.blockParams,
chained: program.chained,
loc: this.source.spanFor(program.loc)
});
}
var i,
l = program.body.length;
this.elementStack.push(node);
if (l === 0) {
return this.elementStack.pop();
}
for (i = 0; i < l; i++) {
this.acceptNode(program.body[i]);
} // Ensure that that the element stack is balanced properly.
var poppedNode = this.elementStack.pop();
if (poppedNode !== node) {
var elementNode = poppedNode;
throw (0, _syntaxError.generateSyntaxError)("Unclosed element `" + elementNode.tag + "`", elementNode.loc);
}
return node;
};
_proto.BlockStatement = function BlockStatement(block) {
if (this.tokenizer.state === "comment"
/* comment */
) {
this.appendToCommentData(this.sourceForNode(block));
return;
}
if (this.tokenizer.state !== "data"
/* data */
&& this.tokenizer.state !== "beforeData"
/* beforeData */
) {
throw (0, _syntaxError.generateSyntaxError)('A block may only be used inside an HTML element or another block.', this.source.spanFor(block.loc));
}
var _acceptCallNodes = acceptCallNodes(this, block),
path = _acceptCallNodes.path,
params = _acceptCallNodes.params,
hash = _acceptCallNodes.hash; // These are bugs in Handlebars upstream
if (!block.program.loc) {
block.program.loc = _location.NON_EXISTENT_LOCATION;
}
if (block.inverse && !block.inverse.loc) {
block.inverse.loc = _location.NON_EXISTENT_LOCATION;
}
var program = this.Program(block.program);
var inverse = block.inverse ? this.Program(block.inverse) : null;
var node = _parserBuilders.default.block({
path: path,
params: params,
hash: hash,
defaultBlock: program,
elseBlock: inverse,
loc: this.source.spanFor(block.loc),
openStrip: block.openStrip,
inverseStrip: block.inverseStrip,
closeStrip: block.closeStrip
});
var parentProgram = this.currentElement();
(0, _utils.appendChild)(parentProgram, node);
};
_proto.MustacheStatement = function MustacheStatement(rawMustache) {
var tokenizer = this.tokenizer;
if (tokenizer.state === 'comment') {
this.appendToCommentData(this.sourceForNode(rawMustache));
return;
}
var mustache;
var escaped = rawMustache.escaped,
loc = rawMustache.loc,
strip = rawMustache.strip;
if ((0, _utils.isHBSLiteral)(rawMustache.path)) {
mustache = _parserBuilders.default.mustache({
path: this.acceptNode(rawMustache.path),
params: [],
hash: _parserBuilders.default.hash([], this.source.spanFor(rawMustache.path.loc).collapse('end')),
trusting: !escaped,
loc: this.source.spanFor(loc),
strip: strip
});
} else {
var _acceptCallNodes2 = acceptCallNodes(this, rawMustache),
path = _acceptCallNodes2.path,
params = _acceptCallNodes2.params,
hash = _acceptCallNodes2.hash;
mustache = _parserBuilders.default.mustache({
path: path,
params: params,
hash: hash,
trusting: !escaped,
loc: this.source.spanFor(loc),
strip: strip
});
}
switch (tokenizer.state) {
// Tag helpers
case "tagOpen"
/* tagOpen */
:
case "tagName"
/* tagName */
:
throw (0, _syntaxError.generateSyntaxError)("Cannot use mustaches in an elements tagname", mustache.loc);
case "beforeAttributeName"
/* beforeAttributeName */
:
addElementModifier(this.currentStartTag, mustache);
break;
case "attributeName"
/* attributeName */
:
case "afterAttributeName"
/* afterAttributeName */
:
this.beginAttributeValue(false);
this.finishAttributeValue();
addElementModifier(this.currentStartTag, mustache);
tokenizer.transitionTo("beforeAttributeName"
/* beforeAttributeName */
);
break;
case "afterAttributeValueQuoted"
/* afterAttributeValueQuoted */
:
addElementModifier(this.currentStartTag, mustache);
tokenizer.transitionTo("beforeAttributeName"
/* beforeAttributeName */
);
break;
// Attribute values
case "beforeAttributeValue"
/* beforeAttributeValue */
:
this.beginAttributeValue(false);
this.appendDynamicAttributeValuePart(mustache);
tokenizer.transitionTo("attributeValueUnquoted"
/* attributeValueUnquoted */
);
break;
case "attributeValueDoubleQuoted"
/* attributeValueDoubleQuoted */
:
case "attributeValueSingleQuoted"
/* attributeValueSingleQuoted */
:
case "attributeValueUnquoted"
/* attributeValueUnquoted */
:
this.appendDynamicAttributeValuePart(mustache);
break;
// TODO: Only append child when the tokenizer state makes
// sense to do so, otherwise throw an error.
default:
(0, _utils.appendChild)(this.currentElement(), mustache);
}
return mustache;
};
_proto.appendDynamicAttributeValuePart = function appendDynamicAttributeValuePart(part) {
this.finalizeTextPart();
var attr = this.currentAttr;
attr.isDynamic = true;
attr.parts.push(part);
};
_proto.finalizeTextPart = function finalizeTextPart() {
var attr = this.currentAttr;
var text = attr.currentPart;
if (text !== null) {
this.currentAttr.parts.push(text);
this.startTextPart();
}
};
_proto.startTextPart = function startTextPart() {
this.currentAttr.currentPart = null;
};
_proto.ContentStatement = function ContentStatement(content) {
updateTokenizerLocation(this.tokenizer, content);
this.tokenizer.tokenizePart(content.value);
this.tokenizer.flushData();
};
_proto.CommentStatement = function CommentStatement(rawComment) {
var tokenizer = this.tokenizer;
if (tokenizer.state === "comment"
/* comment */
) {
this.appendToCommentData(this.sourceForNode(rawComment));
return null;
}
var value = rawComment.value,
loc = rawComment.loc;
var comment = _parserBuilders.default.mustacheComment(value, this.source.spanFor(loc));
switch (tokenizer.state) {
case "beforeAttributeName"
/* beforeAttributeName */
:
case "afterAttributeName"
/* afterAttributeName */
:
this.currentStartTag.comments.push(comment);
break;
case "beforeData"
/* beforeData */
:
case "data"
/* data */
:
(0, _utils.appendChild)(this.currentElement(), comment);
break;
default:
throw (0, _syntaxError.generateSyntaxError)("Using a Handlebars comment when in the `" + tokenizer['state'] + "` state is not supported", this.source.spanFor(rawComment.loc));
}
return comment;
};
_proto.PartialStatement = function PartialStatement(partial) {
throw (0, _syntaxError.generateSyntaxError)("Handlebars partials are not supported", this.source.spanFor(partial.loc));
};
_proto.PartialBlockStatement = function PartialBlockStatement(partialBlock) {
throw (0, _syntaxError.generateSyntaxError)("Handlebars partial blocks are not supported", this.source.spanFor(partialBlock.loc));
};
_proto.Decorator = function Decorator(decorator) {
throw (0, _syntaxError.generateSyntaxError)("Handlebars decorators are not supported", this.source.spanFor(decorator.loc));
};
_proto.DecoratorBlock = function DecoratorBlock(decoratorBlock) {
throw (0, _syntaxError.generateSyntaxError)("Handlebars decorator blocks are not supported", this.source.spanFor(decoratorBlock.loc));
};
_proto.SubExpression = function SubExpression(sexpr) {
var _acceptCallNodes3 = acceptCallNodes(this, sexpr),
path = _acceptCallNodes3.path,
params = _acceptCallNodes3.params,
hash = _acceptCallNodes3.hash;
return _parserBuilders.default.sexpr({
path: path,
params: params,
hash: hash,
loc: this.source.spanFor(sexpr.loc)
});
};
_proto.PathExpression = function PathExpression(path) {
var original = path.original;
var parts;
if (original.indexOf('/') !== -1) {
if (original.slice(0, 2) === './') {
throw (0, _syntaxError.generateSyntaxError)("Using \"./\" is not supported in Glimmer and unnecessary", this.source.spanFor(path.loc));
}
if (original.slice(0, 3) === '../') {
throw (0, _syntaxError.generateSyntaxError)("Changing context using \"../\" is not supported in Glimmer", this.source.spanFor(path.loc));
}
if (original.indexOf('.') !== -1) {
throw (0, _syntaxError.generateSyntaxError)("Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths", this.source.spanFor(path.loc));
}
parts = [path.parts.join('/')];
} else if (original === '.') {
throw (0, _syntaxError.generateSyntaxError)("'.' is not a supported path in Glimmer; check for a path with a trailing '.'", this.source.spanFor(path.loc));
} else {
parts = path.parts;
}
var thisHead = false; // This is to fix a bug in the Handlebars AST where the path expressions in
// `{{this.foo}}` (and similarly `{{foo-bar this.foo named=this.foo}}` etc)
// are simply turned into `{{foo}}`. The fix is to push it back onto the
// parts array and let the runtime see the difference. However, we cannot
// simply use the string `this` as it means literally the property called
// "this" in the current context (it can be expressed in the syntax as
// `{{[this]}}`, where the square bracket are generally for this kind of
// escaping – such as `{{foo.["bar.baz"]}}` would mean lookup a property
// named literally "bar.baz" on `this.foo`). By convention, we use `null`
// for this purpose.
if (original.match(/^this(\..+)?$/)) {
thisHead = true;
}
var pathHead;
if (thisHead) {
pathHead = {
type: 'ThisHead',
loc: {
start: path.loc.start,
end: {
line: path.loc.start.line,
column: path.loc.start.column + 4
}
}
};
} else if (path.data) {
var head = parts.shift();
if (head === undefined) {
throw (0, _syntaxError.generateSyntaxError)("Attempted to parse a path expression, but it was not valid. Paths beginning with @ must start with a-z.", this.source.spanFor(path.loc));
}
pathHead = {
type: 'AtHead',
name: "@" + head,
loc: {
start: path.loc.start,
end: {
line: path.loc.start.line,
column: path.loc.start.column + head.length + 1
}
}
};
} else {
var _head = parts.shift();
if (_head === undefined) {
throw (0, _syntaxError.generateSyntaxError)("Attempted to parse a path expression, but it was not valid. Paths must start with a-z or A-Z.", this.source.spanFor(path.loc));
}
pathHead = {
type: 'VarHead',
name: _head,
loc: {
start: path.loc.start,
end: {
line: path.loc.start.line,
column: path.loc.start.column + _head.length
}
}
};
}
return new _legacyInterop.PathExpressionImplV1(path.original, pathHead, parts, this.source.spanFor(path.loc));
};
_proto.Hash = function Hash(hash) {
var pairs = [];
for (var i = 0; i < hash.pairs.length; i++) {
var pair = hash.pairs[i];
pairs.push(_parserBuilders.default.pair({
key: pair.key,
value: this.acceptNode(pair.value),
loc: this.source.spanFor(pair.loc)
}));
}
return _parserBuilders.default.hash(pairs, this.source.spanFor(hash.loc));
};
_proto.StringLiteral = function StringLiteral(string) {
return _parserBuilders.default.literal({
type: 'StringLiteral',
value: string.value,
loc: string.loc
});
};
_proto.BooleanLiteral = function BooleanLiteral(_boolean) {
return _parserBuilders.default.literal({
type: 'BooleanLiteral',
value: _boolean.value,
loc: _boolean.loc
});
};
_proto.NumberLiteral = function NumberLiteral(number) {
return _parserBuilders.default.literal({
type: 'NumberLiteral',
value: number.value,
loc: number.loc
});
};
_proto.UndefinedLiteral = function UndefinedLiteral(undef) {
return _parserBuilders.default.literal({
type: 'UndefinedLiteral',
value: undefined,
loc: undef.loc
});
};
_proto.NullLiteral = function NullLiteral(nul) {
return _parserBuilders.default.literal({
type: 'NullLiteral',
value: null,
loc: nul.loc
});
};
_createClass(HandlebarsNodeVisitors, [{
key: "isTopLevel",
get: function get() {
return this.elementStack.length === 0;
}
}]);
return HandlebarsNodeVisitors;
}(_parser.Parser);
exports.HandlebarsNodeVisitors = HandlebarsNodeVisitors;
function calculateRightStrippedOffsets(original, value) {
if (value === '') {
// if it is empty, just return the count of newlines
// in original
return {
lines: original.split('\n').length - 1,
columns: 0
};
} // otherwise, return the number of newlines prior to
// `value`
var difference = original.split(value)[0];
var lines = difference.split(/\n/);
var lineCount = lines.length - 1;
return {
lines: lineCount,
columns: lines[lineCount].length
};
}
function updateTokenizerLocation(tokenizer, content) {
var line = content.loc.start.line;
var column = content.loc.start.column;
var offsets = calculateRightStrippedOffsets(content.original, content.value);
line = line + offsets.lines;
if (offsets.lines) {
column = offsets.columns;
} else {
column = column + offsets.columns;
}
tokenizer.line = line;
tokenizer.column = column;
}
function acceptCallNodes(compiler, node) {
if (node.path.type.endsWith('Literal')) {
var _path = node.path;
var value = '';
if (_path.type === 'BooleanLiteral') {
value = _path.original.toString();
} else if (_path.type === 'StringLiteral') {
value = "\"" + _path.original + "\"";
} else if (_path.type === 'NullLiteral') {
value = 'null';
} else if (_path.type === 'NumberLiteral') {
value = _path.value.toString();
} else {
value = 'undefined';
}
throw (0, _syntaxError.generateSyntaxError)(_path.type + " \"" + (_path.type === 'StringLiteral' ? _path.original : value) + "\" cannot be called as a sub-expression, replace (" + value + ") with " + value, compiler.source.spanFor(_path.loc));
}
var path = node.path.type === 'PathExpression' ? compiler.PathExpression(node.path) : compiler.SubExpression(node.path);
var params = node.params ? node.params.map(function (e) {
return compiler.acceptNode(e);
}) : []; // if there is no hash, position it as a collapsed node immediately after the last param (or the
// path, if there are also no params)
var end = params.length > 0 ? params[params.length - 1].loc : path.loc;
var hash = node.hash ? compiler.Hash(node.hash) : {
type: 'Hash',
pairs: [],
loc: compiler.source.spanFor(end).collapse('end')
};
return {
path: path,
params: params,
hash: hash
};
}
function addElementModifier(element, mustache) {
var path = mustache.path,
params = mustache.params,
hash = mustache.hash,
loc = mustache.loc;
if ((0, _utils.isHBSLiteral)(path)) {
var _modifier = "{{" + (0, _utils.printLiteral)(path) + "}}";
var tag = "<" + element.name + " ... " + _modifier + " ...";
throw (0, _syntaxError.generateSyntaxError)("In " + tag + ", " + _modifier + " is not a valid modifier", mustache.loc);
}
var modifier = _parserBuilders.default.elementModifier({
path: path,
params: params,
hash: hash,
loc: loc
});
element.modifiers.push(modifier);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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