@falsefalse/prettier-plugin-handlebars 0.0.1 → 0.0.3

package/dist/parse/nodes.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrettierIgnoreDirective = getPrettierIgnoreDirective;
+exports.findPrettierIgnoreEnd = findPrettierIgnoreEnd;
+exports.textNode = textNode;
+exports.createUnmatchedNode = createUnmatchedNode;
+exports.contentOffset = contentOffset;
+exports.createMustache = createMustache;
+exports.createStatement = createStatement;
+exports.commentBody = commentBody;
+exports.createComment = createComment;
+/* Turning a token into the node it stands for. The span is the token's, so nothing here scans:
+ * what a construct covers was already settled by the time it gets here. */
+const source_1 = require("../core/source");
+const expression_1 = require("../expression");
+const lex_1 = require("./lex");
+const lookahead_1 = require("./lookahead");
+/**
+ * The directive has to *be* the comment, not appear somewhere inside it: on `includes`, a
+ * comment merely mentioning `prettier-ignore` would silently suppress the next node, and one
+ * mentioning `prettier-ignore-start` would open a region.
+ */
+function getPrettierIgnoreDirective(rawContent) {
+    switch (rawContent.toLowerCase().replace(/^\s*!(?:-{2})?/u, '').trim()) {
+        case 'prettier-ignore-start':
+            return 'start';
+        case 'prettier-ignore-end':
+            return 'end';
+        case 'prettier-ignore':
+            return 'next';
+        default:
+            return null;
+    }
+}
+function findPrettierIgnoreEnd(text, position) {
+    for (const token of (0, lookahead_1.mustachesFrom)(text, position)) {
+        /* Kind first: `commentBody` and the directive lookup are wasted on every mustache, block and
+         * partial the scan walks past on the way. */
+        if (token.kind === 'comment' && getPrettierIgnoreDirective(commentBody(token)) === 'end') {
+            return token.end;
+        }
+    }
+    return null;
+}
+/** A run of source kept as text. `verbatim` means the printer reproduces it rather than reflowing. */
+function textNode(text, start, end, rangeOffset, verbatim = false) {
+    const node = verbatim
+        ? { type: 'TextNode', chars: text.slice(start, end), verbatim }
+        : { type: 'TextNode', chars: text.slice(start, end) };
+    return (0, source_1.withRange)(node, rangeOffset + start, rangeOffset + end);
+}
+function createUnmatchedNode(text, start, end, rangeOffset) {
+    return (0, source_1.withRange)({ type: 'UnmatchedNode', raw: text.slice(start, end) }, rangeOffset + start, rangeOffset + end);
+}
+/** Where `content` begins inside the tag spanning [tagStart, tagEnd), for absolute expression ranges. */
+function contentOffset(text, tagStart, tagEnd, content) {
+    const at = text.slice(tagStart, tagEnd).indexOf(content);
+    return at === -1 ? tagStart : tagStart + at;
+}
+/* The parts every inline statement shares: its call, and the `~` markers on its delimiters. */
+function statementBase(text, token, position, rangeOffset, content) {
+    return {
+        ...(0, expression_1.parseCall)(content, rangeOffset + contentOffset(text, position, token.end, content)),
+        ...(token.trimOpen ? { trimOpen: true } : {}),
+        ...(token.trimClose ? { trimClose: true } : {}),
+    };
+}
+/**
+ * A mustache built from whatever token is in hand, whether or not it reads as one.
+ *
+ * The recovery paths use it for a block that never closes and for a stray `{{else}}` or
+ * `{{/if}}` in a position that cannot reject them.
+ */
+function createMustache(text, token, position, rangeOffset) {
+    /* Annotated, not inferred: `withOptionalRange` is generic, so an unannotated literal widens
+     * `type` to `string` and stops matching the node union. */
+    const node = {
+        type: 'MustacheStatement',
+        triple: token.triple,
+        ...statementBase(text, token, position, rangeOffset, token.content),
+    };
+    return (0, source_1.withOptionalRange)(node, rangeOffset + position, rangeOffset + token.end);
+}
+/**
+ * The node for a token that stands on its own, or null for the three kinds - a block and the two
+ * terminators - whose handling depends on where they appear.
+ *
+ * Every context that reads a mustache needs this dispatch: a program body, an attribute list,
+ * the inside of a value. Written out three times, they had drifted at the recovery arms.
+ */
+function createStatement(text, token, position, rangeOffset) {
+    const start = rangeOffset + position;
+    const end = rangeOffset + token.end;
+    if (token.kind === 'comment') {
+        return createComment(token, start, end);
+    }
+    if (token.kind === 'partial') {
+        const node = {
+            type: 'PartialStatement',
+            ...statementBase(text, token, position, rangeOffset, token.content),
+        };
+        return (0, source_1.withOptionalRange)(node, start, end);
+    }
+    /* Before the mustache arm: a decorator is a mustache token carrying a `*`. */
+    if (token.specialForm === 'decorator') {
+        const node = {
+            type: 'DecoratorStatement',
+            ...statementBase(text, token, position, rangeOffset, token.content.slice(1).trim()),
+        };
+        return (0, source_1.withOptionalRange)(node, start, end);
+    }
+    return token.kind === 'mustache' ? createMustache(text, token, position, rangeOffset) : null;
+}
+/**
+ * A comment's body, with the tag's own `~` markers taken off. They are whitespace control, not
+ * text: printing `rawContent` straight through emits them as body, turning `{{~! x ~}}` into
+ * `{{! ~! x ~ }}` and dropping the stripping the author asked for.
+ */
+function commentBody(token) {
+    let content = token.rawContent;
+    if (token.trimOpen) {
+        content = content.replace(/^([\t ]*)~/u, '$1');
+    }
+    /* A block comment's closing `~` follows the `--`, so it never reached `rawContent`. */
+    if (token.trimClose) {
+        content = content.replace(/~([\t ]*)$/u, '$1');
+    }
+    return content;
+}
+function createComment(token, start, end) {
+    const content = commentBody(token);
+    const isBlockStyle = /^\s*!-{2}/.test(content);
+    /* express-hbs' layout directive is `{{!< name}}`, with nothing between the `!` and the `<`, so
+     * the gap is what distinguishes it. Recognising it by body alone would print the ordinary
+     * comment `{{! < name}}` as a directive, silently wrapping the page in a layout. */
+    const isLayout = /^!<\s*\S/u.test(content.trim());
+    /* Only a block comment's `--` is a marker. Stripping up to two dashes regardless cannot tell
+     * it from a body that opens with one, which turns `{{!-foo}}` into `{{! foo }}`.
+     *
+     * Nothing is stripped from the end: the tokenizer stops before the closing delimiter already,
+     * so doing it again would delete a `--` the author wrote. */
+    const body = content.replace(isBlockStyle ? /^[\t ]*!--/u : /^[\t ]*!/u, '');
+    /* Trailing whitespace comes off first. A space between `{{!--` and the newline is invisible in
+     * the source and left the body not *starting* with one, which silently turned off the
+     * re-indent below - so `{{!-- \n  x\n--}}` and `{{!--\n  x\n--}}` printed differently. */
+    const trimmed = body.replace(/[ \t]+$/gm, '');
+    /* A body the author started on its own line keeps its leading newline; the printer reads that
+     * to decide whether to re-indent it. ASCII whitespace, not `\s`: a non-breaking space is
+     * content the author put there, and `\s` deleted one off the front of a comment body. */
+    const value = trimmed.startsWith('\n') ? trimmed : trimmed.replace(lex_1.leadingWhitespace, '');
+    const isMultiline = /\n/.test(content);
+    return (0, source_1.withOptionalRange)({
+        type: 'CommentStatement',
+        value,
+        multiline: isMultiline,
+        block: isBlockStyle || isMultiline,
+        ...(isLayout ? { layout: true } : {}),
+        ...(token.trimOpen ? { trimOpen: true } : {}),
+        ...(token.trimClose ? { trimClose: true } : {}),
+    }, start, end);
+}

package/dist/parser.d.ts

@@ -1,4 +1,2 @@
 import { Program } from './types';
-import { locEnd, locStart } from 'template-format-core';
-export { locEnd, locStart };
 export declare function parse(text: string): Program;