prettier-plugin-sfmc 0.3.0 → 0.4.0

package/README.md

@@ -36,7 +36,7 @@ All options use the `ampscript` prefix — they control AMPscript formatting beh
 | [`ampscriptQuoteStyle`](docs/options/ampscript-quote-style.md)                                | `"single"` \| `"double"`                                                     | `"single"`      | String quote style                             |
 | [`ampscriptKeywordCase`](docs/options/ampscript-keyword-case.md)                              | `"lower"` \| `"upper"` \| `"preserve"`                                       | `"lower"`       | Keyword casing                                 |
 | [`ampscriptFunctionCase`](docs/options/ampscript-function-case.md)                            | `"upper-camel"` \| `"lower-camel"` \| `"upper"` \| `"lower"` \| `"preserve"` | `"upper-camel"` | Function name casing                           |
-| [`ampscriptBlockLineBreaks`](docs/options/ampscript-block-line-breaks.md)                     | boolean                                                                      | `true`          | Line breaks before/after `%%[ ]%%` blocks      |
+| [`ampscriptBlockLineBreaks`](docs/options/ampscript-block-line-breaks.md)                     | boolean                                                                      | `false`         | Optional line breaks around `%%[ ]%%` when not already at a line boundary |
 | [`ampscriptVarDeclarationStyle`](docs/options/ampscript-var-declaration-style.md)             | `"auto"` \| `"single-line"` \| `"multi-line"`                                | `"multi-line"`  | Var declaration formatting                     |
 
 ### Example `.prettierrc`

package/docs/options/ampscript-block-line-breaks.md

@@ -1,25 +1,31 @@
 # `ampscriptBlockLineBreaks`
 
-> Enforce blank lines before and after `%%[ … ]%%` block expressions.
+> Optionally insert line breaks before and after `%%[ … ]%%` block expressions when they are **not** already at a line boundary in the source.
 
 | | |
 |---|---|
 | **Type** | `boolean` |
-| **Default** | `true` |
+| **Default** | `false` |
 | **Applied by** | `prettier --write` · VS Code format-on-save (requires the [Prettier extension](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)) |
 
 ## What It Controls
 
-Adds an empty line before and after every AMPscript block (`%%[ … ]%%`) to visually separate logic from surrounding HTML or text content. Inline expressions (`%%= … =%%`) are never affected. Set to `false` when blocks are embedded in contexts — such as attribute values or tightly formatted output sections — where extra blank lines would break the template layout.
+When set to `true`, Prettier may add a **single** mandatory line break before the opening delimiter and/or after the closing delimiter so the block is not glued to other text on the same line (for example `</p>%%[` or `]%%<p>`).
+
+Breaks are **not** added when the opening is already at the start of a logical line (beginning of file after optional UTF-8 BOM, optional spaces/tabs only before `%%[`, or immediately after `\n` / `\r\n` / `\r`), or when the closing is already at the end of a logical line (only horizontal whitespace until the next line break or end of file). That keeps formatting **idempotent** on repeated save instead of growing extra blank lines.
+
+Inline expressions (`%%= … =%%`) are never affected.
+
+The default is `false` so SMS and other line-break–sensitive templates are not altered unless you opt in.
 
 ## Settings
 
 | Value | Effect |
 |-------|--------|
-| `true` (default) | Blank line inserted before and after every `%%[ ]%%` block |
-| `false` | No blank lines added; blocks formatted flush with surrounding content |
+| `false` (default) | No extra outer line breaks from this option; inner block layout still normalizes |
+| `true` | Add outer line breaks only where the block is not already isolated on its own line |
 
-### `true` (default)
+### `true` — inline-adjacent block
 
 **Input:**
 
@@ -30,35 +36,26 @@ set @name = "Alice"
 ]%%<p>%%=v(@name)=%%</p>
 ```
 
-**Output:**
-
-```html
-<p>Hello</p>
+**Output** (illustrative; exact HTML wrapping may include normal Prettier line breaks):
 
-%%[
-  var @name
-  set @name = "Alice"
-]%%
+- A line break is inserted so `%%[` is not on the same line as `</p>`.
+- A line break is inserted so `]%%` is not on the same line as `<p>`.
 
-<p>%%= v(@name) =%%</p>
-```
+### `true` — already line-isolated (no extra outer breaks)
 
-### `false`
+If the source already has `%%[` at the beginning of a line (after optional BOM / spaces / tabs) and `]%%` at the end of a line (before optional spaces and `\n` or EOF), enabling this option does **not** add further outer breaks, so the document does not grow on every format.
 
-**Output:**
+### `false` (default)
 
-```html
-<p>Hello</p>%%[
-  var @name
-  set @name = "Alice"
-]%%<p>%%= v(@name) =%%</p>
-```
+**Output:** blocks stay flush with surrounding content except for whatever the HTML / AMPscript printers do for normal indentation and line wrapping.
 
 ## Configuration Example
 
+Opt in when you want blocks separated from inline HTML only where needed:
+
 ```json
 {
     "plugins": ["prettier-plugin-sfmc"],
-    "ampscriptBlockLineBreaks": false
+    "ampscriptBlockLineBreaks": true
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "prettier-plugin-sfmc",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "Prettier plugin for Salesforce Marketing Cloud — AMPscript, SSJS, and SQL formatting",
     "type": "module",
     "main": "src/index.js",
@@ -27,6 +27,7 @@
         "test": "node ./scripts/run-jest.mjs",
         "lint": "eslint .",
         "lint:fix": "eslint --fix .",
+        "prepare": "husky || true",
         "format": "prettier --write .",
         "format:check": "prettier --check ."
     },
@@ -59,6 +60,7 @@
         "eslint-plugin-prettier": "^5.5.0",
         "eslint-plugin-unicorn": "^64.0.0",
         "globals": "^17.4.0",
+        "husky": "^9.1.7",
         "jest": "^29.0.0",
         "prettier": "^3.8.1"
     },

package/src/ampscript-block-boundaries.js

@@ -0,0 +1,88 @@
+/**
+ * Detect whether AMPscript block delimiters already sit on their own logical
+ * lines in the original source (LF, CRLF, or CR). Used to avoid Prettier
+ * hardlines that would accumulate on repeated format.
+ *
+ * @param {string} ch
+ */
+function isHorizontalSpaceOrBom(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\uFEFF';
+}
+
+/**
+ * True if `index` is the first non–BOM/horizontal-ws column of a line
+ * (BOF, or only BOM/ws before index, or newline before index after skipping ws).
+ *
+ * @param {string} text
+ * @param {number} index
+ */
+function isIndexAtLineStart(text, index) {
+    if (index <= 0) {
+        return true;
+    }
+
+    let i = index - 1;
+    while (i >= 0 && isHorizontalSpaceOrBom(text[i])) {
+        i--;
+    }
+
+    if (i < 0) {
+        return true;
+    }
+
+    const ch = text[i];
+    return ch === '\n' || ch === '\r';
+}
+
+/**
+ * True if everything from `index` to EOF is horizontal ws/BOM, or the first
+ * non-ws character begins a new line.
+ *
+ * @param {string} text
+ * @param {number} index
+ */
+function isIndexAtLineEnd(text, index) {
+    const len = text.length;
+    let j = index;
+
+    while (j < len && isHorizontalSpaceOrBom(text[j])) {
+        j++;
+    }
+
+    if (j >= len) {
+        return true;
+    }
+
+    const ch = text[j];
+    return ch === '\n' || ch === '\r';
+}
+
+/**
+ * When ampscriptBlockLineBreaks is enabled, add a leading hardline only if
+ * the block opening is not already at the start of a line in the source.
+ *
+ * @param {string | undefined} originalText
+ * @param {number | undefined} blockStart
+ */
+export function needsLeadingBlockBreak(originalText, blockStart) {
+    if (typeof originalText !== 'string' || blockStart == null || blockStart < 0) {
+        return false;
+    }
+
+    return !isIndexAtLineStart(originalText, blockStart);
+}
+
+/**
+ * When ampscriptBlockLineBreaks is enabled, add a trailing hardline only if
+ * the block closing is not already at the end of a line in the source.
+ *
+ * @param {string | undefined} originalText
+ * @param {number | undefined} blockEnd
+ */
+export function needsTrailingBlockBreak(originalText, blockEnd) {
+    if (typeof originalText !== 'string' || blockEnd == null || blockEnd < 0) {
+        return false;
+    }
+
+    return !isIndexAtLineEnd(originalText, blockEnd);
+}

package/src/index.js

@@ -333,11 +333,12 @@ const sfmcOptions = {
     ampscriptBlockLineBreaks: {
         type: 'boolean',
         category: 'AMPscript',
-        default: true,
+        default: false,
         description:
-            'Enforce line breaks before and after %%[ ... ]%% blocks. ' +
+            'When true, insert line breaks before and after %%[ ... ]%% blocks only when the ' +
+            'opening/closing delimiters are not already at a line boundary in the source. ' +
             'Inline expressions (%%= ... =%%) are never affected. ' +
-            'Set to false when blocks are embedded in contexts where extra line breaks are unwanted.',
+            'Default is false to avoid surprising line breaks in SMS and similar contexts.',
     },
     ampscriptVarDeclarationStyle: {
         type: 'choice',

package/src/printer.js

@@ -8,6 +8,7 @@
 
 import * as prettier from 'prettier';
 import { FUNCTION_CANONICAL_MAP, AMPSCRIPT_KEYWORDS } from 'ampscript-data';
+import { needsLeadingBlockBreak, needsTrailingBlockBreak } from './ampscript-block-boundaries.js';
 
 const { group, indent, join, line, softline, hardline } = prettier.doc.builders;
 
@@ -203,7 +204,7 @@ function printAmpscriptNode(path, options, print) {
     const variableStyle = options.ampscriptVarDeclarationStyle || 'multi-line';
     const keywordCase = options.ampscriptKeywordCase || 'lower';
     const functionCase = options.ampscriptFunctionCase || 'upper-camel';
-    const blockLineBreaks = options.ampscriptBlockLineBreaks !== false;
+    const blockLineBreaks = options.ampscriptBlockLineBreaks === true;
 
     function resolveVariable(variableName) {
         if (!enforceCasing) {
@@ -295,8 +296,21 @@ function printAmpscriptNode(path, options, print) {
                 blockClose,
             ]);
             if (blockLineBreaks) {
-                return [hardline, blockDocument, hardline];
+                const originalText = options.originalText;
+                const parts = [];
+                if (needsLeadingBlockBreak(originalText, node.start)) {
+                    parts.push(hardline);
+                }
+
+                parts.push(blockDocument);
+
+                if (needsTrailingBlockBreak(originalText, node.end)) {
+                    parts.push(hardline);
+                }
+
+                return parts.length === 1 ? parts[0] : parts;
             }
+
             return blockDocument;
         }