@falsefalse/prettier-plugin-handlebars 0.0.1

package/dist/expression.js

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCall = parseCall;
+const template_format_core_1 = require("template-format-core");
+const errors_1 = require("./errors");
+const whitespace = __importStar(require("./whitespace"));
+const quoteCharacters = new Set(['"', "'", '`']);
+const numberPattern = /^-?(?:\d+\.?\d*|\.\d+)$/u;
+function literalTypeOf(source) {
+    switch (source) {
+        case 'true':
+        case 'false':
+            return 'BooleanLiteral';
+        case 'null':
+            return 'NullLiteral';
+        case 'undefined':
+            return 'UndefinedLiteral';
+        default:
+            return numberPattern.test(source) ? 'NumberLiteral' : null;
+    }
+}
+/**
+ * Recursive-descent reader over one call's source, e.g. `t 'a.b' n=(concat x y)`.
+ *
+ * Total by construction: anything it cannot classify becomes a PathExpression holding the raw
+ * text, because a formatter has to keep working on templates that are mid-edit.
+ */
+class CallReader {
+    constructor(source, offset) {
+        this.source = source;
+        this.offset = offset;
+        this.index = 0;
+    }
+    get done() {
+        return this.index >= this.source.length;
+    }
+    peek(at = 0) {
+        return this.source[this.index + at] ?? '';
+    }
+    skipWhitespace() {
+        while (!this.done && whitespace.handlebars.test(this.peek())) {
+            this.index += 1;
+        }
+    }
+    span(start, end) {
+        return [this.offset + start, this.offset + end];
+    }
+    /** `as |a b|` closes the parameter list; the names themselves have nothing to break. */
+    readBlockParams() {
+        const rest = this.source.slice(this.index);
+        const match = /^as\s+\|([^|]*)\|/u.exec(rest);
+        if (!match) {
+            return null;
+        }
+        this.index += match[0].length;
+        return match[1].trim().split(whitespace.handlebarsRun).filter(Boolean);
+    }
+    skipQuoted() {
+        const quote = this.peek();
+        this.index += 1;
+        while (!this.done) {
+            const char = this.peek();
+            if (char === '\\') {
+                this.index += 2;
+                continue;
+            }
+            this.index += 1;
+            if (char === quote) {
+                break;
+            }
+        }
+    }
+    /** A bare run stops at whitespace, a closing paren, or the `=` of a hash pair. */
+    skipBare() {
+        let brackets = 0;
+        while (!this.done) {
+            const char = this.peek();
+            if (char === '[')
+                brackets += 1;
+            else if (char === ']')
+                brackets = Math.max(brackets - 1, 0);
+            else if (brackets === 0 && (whitespace.handlebars.test(char) || char === ')' || char === '='))
+                break;
+            this.index += 1;
+        }
+    }
+    /** A leaf is its own source text and the span it came from; only the label differs. */
+    leaf(type, start) {
+        const node = { type, source: this.source.slice(start, this.index) };
+        return (0, template_format_core_1.withRange)(node, ...this.span(start, this.index));
+    }
+    readSubExpression() {
+        const start = this.index;
+        this.index += 1;
+        const inner = this.readCall(true);
+        /* Printing the parts back out would invent the `)` the author did not write, turning a
+         * template Handlebars rejects into one it accepts - the opposite of what this branch does
+         * everywhere else. */
+        if (this.peek() !== ')') {
+            throw new errors_1.TemplateSyntaxError("unterminated subexpression: expected ')'", ...this.span(start, this.index));
+        }
+        this.index += 1;
+        const node = {
+            type: 'SubExpression',
+            source: this.source.slice(start, this.index),
+            path: inner.path,
+            params: inner.params,
+            hash: inner.hash,
+        };
+        return (0, template_format_core_1.withRange)(node, ...this.span(start, this.index));
+    }
+    readValue() {
+        if (this.peek() === '(') {
+            return this.readSubExpression();
+        }
+        const start = this.index;
+        if (quoteCharacters.has(this.peek())) {
+            this.skipQuoted();
+            return this.leaf('StringLiteral', start);
+        }
+        this.skipBare();
+        /* An empty read would spin forever; consume the character as a path instead. */
+        if (this.index === start) {
+            this.index += 1;
+        }
+        return this.leaf(literalTypeOf(this.source.slice(start, this.index)) ?? 'PathExpression', start);
+    }
+    /** A head must be callable, so a stray literal is reread as a path rather than rejected. */
+    readHead() {
+        const value = this.readValue();
+        if (value.type === 'SubExpression' || value.type === 'PathExpression') {
+            return value;
+        }
+        const node = { type: 'PathExpression', source: value.source };
+        return value.range ? (0, template_format_core_1.withRange)(node, ...value.range) : node;
+    }
+    readCall(nested = false) {
+        this.skipWhitespace();
+        const path = this.done || this.peek() === ')' ? this.emptyPath() : this.readHead();
+        const params = [];
+        const hash = [];
+        let blockParams;
+        for (;;) {
+            this.skipWhitespace();
+            if (this.done || (nested && this.peek() === ')')) {
+                break;
+            }
+            const names = this.readBlockParams();
+            if (names) {
+                blockParams = names;
+                continue;
+            }
+            const start = this.index;
+            const value = this.readValue();
+            /* Handlebars allows space on either side of the `=`, so look past it and rewind when the
+             * next token turns out to be a plain param rather than a hash value. */
+            const afterValue = this.index;
+            this.skipWhitespace();
+            if (this.peek() === '=' && value.type === 'PathExpression') {
+                this.index += 1;
+                this.skipWhitespace();
+                const pairValue = this.readValue();
+                hash.push((0, template_format_core_1.withRange)({ key: value.source, value: pairValue }, ...this.span(start, this.index)));
+                continue;
+            }
+            this.index = afterValue;
+            /* Handlebars rejects a positional param after a hash pair, and the printer prints params
+             * first regardless - so accepting this would silently re-order the author's arguments. */
+            if (hash.length > 0) {
+                throw new errors_1.TemplateSyntaxError(`unexpected ${value.source} after a hash pair: positional params come first`, ...this.span(start, this.index));
+            }
+            params.push(value);
+        }
+        return blockParams ? { path, params, hash, blockParams } : { path, params, hash };
+    }
+    emptyPath() {
+        const node = { type: 'PathExpression', source: '' };
+        return (0, template_format_core_1.withRange)(node, ...this.span(this.index, this.index));
+    }
+}
+/**
+ * Parses one call's source into structured parts whose ranges are absolute in the template.
+ *
+ * `offset` is where `source` begins in the template, so a subexpression buried in a hash value
+ * can still be located exactly.
+ */
+function parseCall(source, offset = 0) {
+    return new CallReader(source, offset).readCall();
+}

package/dist/parser.d.ts

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