@falsefalse/prettier-plugin-handlebars 0.0.2 → 0.0.3

package/dist/plugin.d.ts

@@ -1,4 +1,5 @@
-import { locEnd, locStart, parse } from './parser';
+import { locEnd, locStart } from './core/source';
+import { parse } from './parser';
 export declare const languages: {
     name: string;
     type: string;

package/dist/plugin.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOptions = exports.options = exports.printers = exports.parsers = exports.languages = void 0;
+const source_1 = require("./core/source");
 const parser_1 = require("./parser");
 const printer_1 = require("./printer");
 exports.languages = [
@@ -17,8 +18,8 @@ exports.parsers = {
     'handlebars': {
         parse: parser_1.parse,
         astFormat: 'handlebars-ast',
-        locStart: parser_1.locStart,
-        locEnd: parser_1.locEnd,
+        locStart: source_1.locStart,
+        locEnd: source_1.locEnd,
     },
 };
 exports.printers = {

package/dist/printer.d.ts

@@ -1,8 +1,3 @@
-import type { ParserOptions, Printer } from 'prettier';
+import type { Printer } from 'prettier';
 import type { Node } from './types';
-/** Only prettier's core options reach the printer; this formatter is opinionated. */
-export type PrintOptions = Pick<ParserOptions<Node>, 'singleQuote'> & {
-    /** Quote holding the value being printed into. Unusable by anything nested in it. */
-    enclosingQuote?: '"' | "'";
-};
 export declare const printer: Printer<Node>;

package/dist/printer.js

@@ -35,9 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printer = void 0;
 const doc_1 = require("prettier/doc");
-const template_format_core_1 = require("template-format-core");
+const html_1 = require("./core/html");
 const tokens_1 = require("./dialects/handlebars/tokens");
-const whitespace = __importStar(require("./whitespace"));
+const whitespace = __importStar(require("./core/whitespace"));
 const { dedent, fill, group, hardline, ifBreak, indent, join, line, literalline, softline } = doc_1.builders;
 const { removeLines } = doc_1.utils;
 /* A run of blank lines collapses to one, which is two hardlines. */
@@ -192,13 +192,15 @@ function contentSpan(pieces) {
         end -= 1;
     return [start, end];
 }
-function printExpression(expression, breakable) {
-    return expression.type === 'SubExpression' ? printCall(expression, '(', ')', breakable) : expression.source;
+function printExpression(expression, breakable, options) {
+    return expression.type === 'SubExpression'
+        ? printCall(expression, '(', ')', options, breakable)
+        : printSource(expression.source, options);
 }
-function printCallParts(call, breakable) {
-    const parts = call.params.map((param) => printExpression(param, breakable));
+function printCallParts(call, breakable, options) {
+    const parts = call.params.map((param) => printExpression(param, breakable, options));
     for (const pair of call.hash) {
-        parts.push([pair.key, '=', printExpression(pair.value, breakable)]);
+        parts.push([pair.key, '=', printExpression(pair.value, breakable, options)]);
     }
     if (call.blockParams && call.blockParams.length > 0) {
         parts.push(['as |', call.blockParams.join(' '), '|']);
@@ -206,22 +208,22 @@ function printCallParts(call, breakable) {
     return parts;
 }
 /** Whitespace inside a mustache does not render, so it is the formatter's: all-or-nothing. */
-function printCall(call, open, close, breakable = true) {
-    const parts = printCallParts(call, breakable);
+function printCall(call, open, close, options, breakable = true) {
+    const parts = printCallParts(call, breakable, options);
     if (parts.length === 0) {
-        return [open, printExpression(call.path, breakable), close];
+        return [open, printExpression(call.path, breakable, options), close];
     }
     if (!breakable) {
-        return [open, printExpression(call.path, false), ' ', join(' ', parts), close];
+        return [open, printExpression(call.path, false, options), ' ', join(' ', parts), close];
     }
     /* One group, so a call that does not fit breaks every one of its parts. */
-    return group([open, indent([printExpression(call.path, true), line, join(line, parts)]), softline, close]);
+    return group([open, indent([printExpression(call.path, true, options), line, join(line, parts)]), softline, close]);
 }
 /* The three inline statements are one call in different delimiters: a mustache in `{{}}` (or
  * `{{{}}}` when unescaped), a partial in `{{> }}`, a decorator in `{{*}}`. */
-function printStatement(node, prefix) {
+function printStatement(node, prefix, options) {
     const triple = node.type === 'MustacheStatement' && node.triple;
-    return printCall(node, [triple ? '{{{' : '{{', trim(node.trimOpen), prefix], [trim(node.trimClose), triple ? '}}}' : '}}']);
+    return printCall(node, [triple ? '{{{' : '{{', trim(node.trimOpen), prefix], [trim(node.trimClose), triple ? '}}}' : '}}'], options);
 }
 function printComment(node) {
     /* `block` already covers a multiline body - the parser sets it for either - so re-testing
@@ -240,7 +242,7 @@ function printComment(node) {
      * the surrounding structure instead of staying frozen at the column it was written at.
      * Common indentation is stripped and re-applied, which keeps the body's *relative* shape. */
     if (/^\n/u.test(body)) {
-        const lines = (0, template_format_core_1.stripCommonIndent)(body.replace(/^\n/u, '').replace(trailingWhitespace, '').split('\n'));
+        const lines = whitespace.stripCommonIndent(body.replace(/^\n/u, '').replace(trailingWhitespace, '').split('\n'));
         return lines.every((line) => line === '')
             ? [open, hardline, close]
             : [open, indent([hardline, join(hardline, lines)]), hardline, close];
@@ -261,24 +263,55 @@ function printComment(node) {
     const tail = whitespace.html.test(body[body.length - 1] ?? '') ? '' : ' ';
     return [open, lead, join(literalline, body.split('\n')), tail, close];
 }
+/* Handlebars escapes only the quote that closes the literal: `\n` is a backslash and an `n`,
+ * and `\\` is two backslashes. So unescaping is one replacement and re-escaping is its inverse,
+ * and a value can always be written in either quote. */
+const isQuoted = (source) => source.length >= 2 && (source[0] === '"' || source[0] === "'") && source[source.length - 1] === source[0];
+const unquote = (source) => source.slice(1, -1).split(`\\${source[0]}`).join(source[0]);
+/* House style: `"` around an attribute value, `'` around a string literal in a mustache. The two
+ * are complementary, so a literal inside an attribute already wears the quote the attribute did
+ * not, and neither has to give way - which is what makes a template read the same throughout.
+ * Both still yield to the quote they sit inside, and to whichever one needs no escaping. */
+const ATTRIBUTE_QUOTE = '"';
+const LITERAL_QUOTE = "'";
+const otherQuote = (quote) => (quote === '"' ? "'" : '"');
 /**
- * The quote that needs no escaping; `singleQuote` decides only when either would do.
+ * The house quote, unless the text already holds it or it is the one enclosing this.
  *
- * Against the value's raw text, not just its TextNode parts: a quote inside a mustache is printed
- * too, so `class='{{t "x"}}'` cannot be re-quoted with `"` without ending the attribute early.
+ * A quote ends the run it opened, so the enclosing one is unusable at any price: `class="{{t
+ * "x"}}"` ends the attribute at the second `"` and the rest of the tag becomes something else.
+ * Text holding the other quote is only worth an escape, and an attribute has none to spend, so
+ * both callers want the quote their text does not hold.
  */
-/* A quote ends the value holding it, so a nested element cannot reuse the outer one. */
-function chooseQuote(value, options) {
-    const preferred = options.singleQuote === true ? "'" : '"';
-    const candidates = [preferred, preferred === '"' ? "'" : '"'];
-    return candidates.find((q) => q !== options.enclosingQuote && !value.raw.includes(q)) ?? preferred;
+function pickQuote(text, house, enclosing) {
+    const usable = [house, otherQuote(house)].filter((quote) => quote !== enclosing);
+    return usable.find((quote) => !text.includes(quote)) ?? usable[0] ?? house;
+}
+/**
+ * A literal or path as it will be printed. A quoted path is a name written as a string -
+ * `{{> 'card'}}` - because the expression reader hands the head back as a path however it was
+ * written, so both go through the same quoting.
+ *
+ * Returns a string rather than a `Doc`: a block's closer has to repeat this exactly, and `Doc`
+ * is not something it can repeat.
+ */
+function printSource(source, options) {
+    if (!isQuoted(source) || options.opaqueQuotes) {
+        return source;
+    }
+    const value = unquote(source);
+    const quote = pickQuote(value, LITERAL_QUOTE, options.enclosingQuote);
+    return quote + value.split(quote).join(`\\${quote}`) + quote;
 }
 function printAttribute(attribute, options) {
     if (attribute.type === 'RawAttribute') {
         return attribute.raw;
     }
+    /* The block's body is text and mustaches, not attributes: `title="` is half of one TextNode,
+     * so nothing downstream can tell which quote - if any - a literal in there sits inside. The
+     * text keeps the author's quotes because it is content; a literal keeps them for company. */
     if (attribute.type === 'AttributeBlock') {
-        return printAny(attribute.block, options);
+        return printAny(attribute.block, { ...options, opaqueQuotes: true });
     }
     if (!attribute.value) {
         return attribute.name;
@@ -288,8 +321,10 @@ function printAttribute(attribute, options) {
      * rendered value. The parser marks the value's text as whitespace-significant, which is what
      * keeps a block's body from being laid out at the printer's indent level instead of the
      * author's - and what lets prettier see where the value's own lines end. */
+    /* Against the value's raw text, not just its TextNode parts: a quote inside a mustache is
+     * printed too, so `class='{{t "x"}}'` cannot be re-quoted with `"` without ending early. */
     const { parts } = attribute.value;
-    const quote = chooseQuote(attribute.value, options);
+    const quote = pickQuote(attribute.value.raw, ATTRIBUTE_QUOTE, options.enclosingQuote);
     const nested = { ...options, enclosingQuote: quote };
     return [attribute.name, '=', quote, ...parts.map((part) => printAny(part, nested)), quote];
 }
@@ -299,7 +334,7 @@ function printAttribute(attribute, options) {
  * a stray bracket rather than a break.
  */
 function printOpenTag(node, options) {
-    const marker = node.selfClosing && !template_format_core_1.voidElements.has(node.tag.toLowerCase()) ? ' />' : '>';
+    const marker = node.selfClosing && !(0, html_1.isVoidElement)(node.tag) ? ' />' : '>';
     if (node.attributes.length === 0) {
         return ['<', node.tag, marker];
     }
@@ -382,11 +417,11 @@ function printBlock(node, options, tail = []) {
     const sections = [
         {
             program: node.program,
-            open: (breakable) => printCall(node, ['{{', trim(node.trimOpen), prefix], [trim(node.trimClose), '}}'], breakable),
+            open: (breakable) => printCall(node, ['{{', trim(node.trimOpen), prefix], [trim(node.trimClose), '}}'], options, breakable),
         },
         ...(node.inverseChain ?? []).map((branch) => ({
             program: branch.program,
-            open: (breakable) => printCall(branch, ['{{', trim(branch.trimOpen), `${elseKeyword} `], [trim(branch.trimClose), '}}'], breakable),
+            open: (breakable) => printCall(branch, ['{{', trim(branch.trimOpen), `${elseKeyword} `], [trim(branch.trimClose), '}}'], options, breakable),
         })),
     ];
     /* An empty `{{else}}` prints nothing - unless it carries `~`, which strips whitespace that
@@ -400,7 +435,7 @@ function printBlock(node, options, tail = []) {
     const close = [
         '{{',
         trim(node.closeTrimOpen),
-        tokens_1.handlebarsDialect.getBlockClosePrefix(node.path.source),
+        tokens_1.handlebarsDialect.getBlockClosePrefix(printSource(node.path.source, options)),
         trim(node.closeTrimClose),
         '}}',
         tail,
@@ -484,11 +519,11 @@ function printAny(node, options) {
         case 'TextNode':
             return assemble(textPieces(node));
         case 'MustacheStatement':
-            return printStatement(node, '');
+            return printStatement(node, '', options);
         case 'PartialStatement':
-            return printStatement(node, '> ');
+            return printStatement(node, '> ', options);
         case 'DecoratorStatement':
-            return printStatement(node, '*');
+            return printStatement(node, '*', options);
         case 'CommentStatement':
             return printComment(node);
         /* `childPieces` intercepts these, so this arm only keeps the switch exhaustive. It goes
@@ -514,10 +549,12 @@ const visitorKeys = {
     ElseBranch: ['program'],
 };
 exports.printer = {
-    /* Only the root reaches this: everything below recurses through printAny. */
-    print(path, options) {
+    /* Only the root reaches this: everything below recurses through printAny. Prettier's options
+     * are not among the arguments because nothing here reads them - the quoting is this
+     * formatter's own, and width and indentation belong to the doc printer. */
+    print(path) {
         const node = path.node;
-        return node.type === 'Program' && path.parent === null ? printRoot(node.body, options) : printAny(node, options);
+        return node.type === 'Program' && path.parent === null ? printRoot(node.body, {}) : printAny(node, {});
     },
     getVisitorKeys(node, nonTraversableKeys) {
         const type = typeof node === 'object' && node !== null && 'type' in node ? String(node.type) : '';

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import type { SourceRange } from 'template-format-core';
-export type { SourceRange } from 'template-format-core';
+import type { SourceRange } from './core/source';
+export type { SourceRange } from './core/source';
 export type Node = Program | ElementNode | TextNode | MustacheStatement | BlockStatement | PartialStatement | DecoratorStatement | CommentStatement | UnmatchedNode;
 export interface Program extends SourceRange {
     type: 'Program';

package/docs/EDITOR_SETUP.md

@@ -7,7 +7,6 @@ The plugin works through Prettier. Editors must be configured so Prettier is sel
 Install:
 
 - [Prettier - Code formatter](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)
-- Optional companion extension: [HBS Master](https://marketplace.visualstudio.com/items?itemName=poliklot.hbs-master)
 
 Recommended workspace settings:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falsefalse/prettier-plugin-handlebars",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Whitespace-aware Handlebars formatter for Prettier",
   "contributors": [
     "Claude <noreply@anthropic.com>"
@@ -45,8 +45,8 @@
   ],
   "scripts": {
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
-    "build": "npm run clean && tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit -p ./ts.base.json",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "typecheck": "tsc",
     "test": "vitest run",
     "test:watch": "vitest",
     "check": "npm run build && npm run typecheck && npm test && npm run gates",
@@ -67,8 +67,5 @@
   },
   "peerDependencies": {
     "prettier": ">=3.0.0"
-  },
-  "dependencies": {
-    "template-format-core": "^0.1.1"
   }
 }