prettier-plugin-sfmc 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "prettier-plugin-sfmc",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "Prettier plugin for Salesforce Marketing Cloud - AMPscript, Marketing Cloud Next Handlebars, SSJS, and SQL formatting",
     "type": "module",
     "main": "src/index.js",
@@ -47,25 +47,25 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "ampscript-data": "^2.0.3",
-        "ampscript-parser": "^0.1.3",
+        "ampscript-data": "^3.0.0",
+        "ampscript-parser": "^0.2.0",
         "handlebars-data": "^0.3.0",
         "prettier-plugin-sql": "^0.20.0",
-        "ssjs-data": "^0.5.0"
+        "ssjs-data": "^0.14.0"
     },
     "devDependencies": {
         "@eslint/js": "^10.0.1",
-        "@jest/globals": "^30.3.0",
-        "eslint": "^10.1.0",
+        "@jest/globals": "^30.4.1",
+        "eslint": "^10.6.0",
         "eslint-config-prettier": "^10.1.8",
-        "eslint-plugin-jsdoc": "^62.0.0",
-        "eslint-plugin-prettier": "^5.5.0",
-        "eslint-plugin-unicorn": "^64.0.0",
-        "globals": "^17.4.0",
+        "eslint-plugin-jsdoc": "^63.0.12",
+        "eslint-plugin-prettier": "^5.5.6",
+        "eslint-plugin-unicorn": "^71.1.0",
+        "globals": "^17.7.0",
         "husky": "^9.1.7",
-        "jest": "^30.3.0",
-        "lint-staged": "^17.0.5",
-        "prettier": "^3.8.1"
+        "jest": "^30.4.2",
+        "lint-staged": "^17.0.8",
+        "prettier": "^3.9.5"
     },
     "peerDependencies": {
         "prettier": ">=3.7.0"

package/src/ampscript-block-boundaries.js

@@ -6,7 +6,7 @@
  * @param {string} ch
  */
 function isHorizontalSpaceOrBom(ch) {
-    return ch === ' ' || ch === '\t' || ch === '\uFEFF';
+    return [' ', '\t', '\u{FEFF}'].includes(ch);
 }
 
 /**
@@ -21,16 +21,16 @@ function isIndexAtLineStart(text, index) {
         return true;
     }
 
-    let i = index - 1;
-    while (i >= 0 && isHorizontalSpaceOrBom(text[i])) {
-        i--;
+    let index_ = index - 1;
+    while (index_ >= 0 && isHorizontalSpaceOrBom(text[index_])) {
+        index_--;
     }
 
-    if (i < 0) {
+    if (index_ < 0) {
         return true;
     }
 
-    const ch = text[i];
+    const ch = text[index_];
     return ch === '\n' || ch === '\r';
 }
 
@@ -42,18 +42,18 @@ function isIndexAtLineStart(text, index) {
  * @param {number} index
  */
 function isIndexAtLineEnd(text, index) {
-    const len = text.length;
-    let j = index;
+    const length = text.length;
+    let index_ = index;
 
-    while (j < len && isHorizontalSpaceOrBom(text[j])) {
-        j++;
+    while (index_ < length && isHorizontalSpaceOrBom(text[index_])) {
+        index_++;
     }
 
-    if (j >= len) {
+    if (index_ >= length) {
         return true;
     }
 
-    const ch = text[j];
+    const ch = text[index_];
     return ch === '\n' || ch === '\r';
 }
 
@@ -65,7 +65,7 @@ function isIndexAtLineEnd(text, index) {
  * @param {number | undefined} blockStart
  */
 export function needsLeadingBlockBreak(originalText, blockStart) {
-    if (typeof originalText !== 'string' || blockStart == null || blockStart < 0) {
+    if (typeof originalText !== 'string' || blockStart == undefined || blockStart < 0) {
         return false;
     }
 
@@ -80,7 +80,7 @@ export function needsLeadingBlockBreak(originalText, blockStart) {
  * @param {number | undefined} blockEnd
  */
 export function needsTrailingBlockBreak(originalText, blockEnd) {
-    if (typeof originalText !== 'string' || blockEnd == null || blockEnd < 0) {
+    if (typeof originalText !== 'string' || blockEnd == undefined || blockEnd < 0) {
         return false;
     }
 

package/src/index.js

@@ -37,7 +37,7 @@ function mergeSqlOptionsWithSfmcDefaults(sqlOptions) {
         dataTypeCase: 'preserve',
     };
     for (const [key, defaultValue] of Object.entries(defaults)) {
-        if (merged[key]) {
+        if (Object.hasOwn(merged, key)) {
             merged[key].default = defaultValue;
         }
     }
@@ -111,21 +111,21 @@ function isBareName(token) {
  * caller, not here.
  *
  * @param {string} inner Raw inner text of a mustache expression.
- * @param {{ helperCase?: 'upper-camel'|'lower-camel'|'upper'|'lower'|'preserve' }} [opts] Options.
+ * @param {{ helperCase?: 'upper-camel'|'lower-camel'|'upper'|'lower'|'preserve' }} [options] Options.
  * @returns {string} Normalized inner text (collapsed whitespace, recased heads).
  */
-function normalizeMustacheInner(inner, opts = {}) {
-    const helperCase = opts.helperCase || 'lower-camel';
+function normalizeMustacheInner(inner, options = {}) {
+    const helperCase = options.helperCase || 'lower-camel';
 
     // First pass: collapse whitespace outside string literals, preserving quotes.
     let collapsed = '';
-    /** @type {string|null} */
-    let quote = null;
+    /** @type {string|undefined} */
+    let quote;
     for (const ch of inner) {
         if (quote) {
             collapsed += ch;
             if (ch === quote) {
-                quote = null;
+                quote = undefined;
             }
             continue;
         }
@@ -134,7 +134,7 @@ function normalizeMustacheInner(inner, opts = {}) {
             collapsed += ch;
             continue;
         }
-        if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r' || ch === '\f' || ch === '\v') {
+        if ([' ', '\t', '\n', '\r', '\f', '\v'].includes(ch)) {
             if (collapsed.length > 0 && collapsed.at(-1) !== ' ') {
                 collapsed += ' ';
             }
@@ -153,60 +153,65 @@ function normalizeMustacheInner(inner, opts = {}) {
     // immediately after each `(`. We walk the collapsed string, tracking string
     // literals so `(` / heads inside quotes are ignored.
     let result = '';
-    quote = null;
-    let expectHead = true;
-    let leadingSigilConsumed = false;
-    let i = 0;
+    quote = undefined;
+    let isExpectHead = true;
+    let isLeadingSigilConsumed = false;
+    let index = 0;
     const n = collapsed.length;
-    while (i < n) {
-        const ch = collapsed[i];
+    while (index < n) {
+        const ch = collapsed[index];
         if (quote) {
             result += ch;
             if (ch === quote) {
-                quote = null;
+                quote = undefined;
             }
-            i++;
+            index++;
             continue;
         }
         if (ch === '"' || ch === "'") {
             quote = ch;
             result += ch;
-            expectHead = false;
-            i++;
+            isExpectHead = false;
+            index++;
             continue;
         }
         // At the outermost head position, skip a single leading sigil.
-        if (expectHead && !leadingSigilConsumed && result.length === 0 && MUSTACHE_SIGILS.has(ch)) {
+        if (
+            isExpectHead &&
+            !isLeadingSigilConsumed &&
+            result.length === 0 &&
+            MUSTACHE_SIGILS.has(ch)
+        ) {
             result += ch;
-            leadingSigilConsumed = true;
-            i++;
+            isLeadingSigilConsumed = true;
+            index++;
             continue;
         }
         if (ch === '(') {
             result += ch;
-            expectHead = true;
-            i++;
+            isExpectHead = true;
+            index++;
             continue;
         }
         if (ch === ' ') {
             result += ch;
-            i++;
+            index++;
             continue;
         }
-        if (expectHead) {
+        if (isExpectHead) {
             // Read the head token up to the next whitespace, `(`, `)`, or quote.
-            let j = i;
-            while (j < n && !/[\s()'"]/.test(collapsed[j])) {
-                j++;
+            let index_ = index;
+            while (index_ < n && !/[\s()'"]/.test(collapsed[index_])) {
+                index_++;
             }
-            const token = collapsed.slice(i, j);
+            const token = collapsed.slice(index, index_);
             result += isBareName(token) ? applyHelperCase(token, helperCase) : token;
-            expectHead = false;
-            i = j;
+            isExpectHead = false;
+            index = index_;
             continue;
         }
         result += ch;
-        i++;
+        index++;
     }
     return result;
 }
@@ -218,6 +223,36 @@ function normalizeMustacheInner(inner, opts = {}) {
  */
 const HANDLEBARS_PH = 'HANDLEBARSPH';
 
+/**
+ * Scan forward from `start` for a Handlebars closing delimiter, ignoring any
+ * occurrence that sits inside a single- or double-quoted string literal.
+ *
+ * @param {string} text Text being scanned.
+ * @param {number} start Index to begin scanning at (just past the opener).
+ * @param {string} closeDelim Closing delimiter to look for (`}}` or `}}}`).
+ * @param {number} end Exclusive upper bound for scanning (usually `text.length`).
+ * @returns {number} Index of the closing delimiter, or `-1` when not found.
+ */
+function findClosingDelimiter(text, start, closeDelim, end) {
+    /** @type {string|undefined} */
+    let quote;
+    let index = start;
+    while (index < end) {
+        const ch = text[index];
+        if (quote) {
+            if (ch === quote) {
+                quote = undefined;
+            }
+        } else if (ch === '"' || ch === "'") {
+            quote = ch;
+        } else if (text.startsWith(closeDelim, index)) {
+            return index;
+        }
+        index++;
+    }
+    return -1;
+}
+
 /**
  * Extract every well-formed MCN Handlebars `{{…}}` region from a string, replacing
  * each with a `HANDLEBARSPH<n>END` placeholder and recording the normalized
@@ -235,15 +270,15 @@ const HANDLEBARS_PH = 'HANDLEBARSPH';
  *   (no throw, no change), so the HTML parser passes them through untouched.
  *
  * @param {string} text Joined HTML/text (AMPscript already placeholdered).
- * @param {{ spacing?: boolean, helperCase?: 'upper-camel'|'lower-camel'|'upper'|'lower'|'preserve' }} [opts]
+ * @param {{ spacing?: boolean, helperCase?: 'upper-camel'|'lower-camel'|'upper'|'lower'|'preserve' }} [options]
  * Formatting options: `spacing` pads simple/triple mustaches (sigil mustaches stay
  * tight); `helperCase` recases known catalog helpers at head positions.
  * @returns {{ html: string, tokens: string[] }} Text with Handlebars placeholders
  * and the ordered list of normalized mustache replacements.
  */
-function extractHandlebarsRegions(text, opts = {}) {
-    const spacing = opts.spacing === true;
-    const helperCase = opts.helperCase || 'lower-camel';
+function extractHandlebarsRegions(text, options = {}) {
+    const isSpacing = options.spacing === true;
+    const helperCase = options.helperCase || 'lower-camel';
     /** @type {string[]} */
     const tokens = [];
     if (typeof text !== 'string' || !text.includes('{{')) {
@@ -251,62 +286,39 @@ function extractHandlebarsRegions(text, opts = {}) {
     }
 
     let out = '';
-    let i = 0;
+    let index = 0;
     const n = text.length;
-    while (i < n) {
-        const open = text.indexOf('{{', i);
+    while (index < n) {
+        const open = text.indexOf('{{', index);
         if (open === -1) {
-            out += text.slice(i);
+            out += text.slice(index);
             break;
         }
-        out += text.slice(i, open);
+        out += text.slice(index, open);
 
         const isTriple = text[open + 2] === '{';
-        const openLen = isTriple ? 3 : 2;
-        const afterOpen = text.slice(open + openLen);
+        const openLength = isTriple ? 3 : 2;
+        const afterOpen = text.slice(open + openLength);
 
         // Comments: record verbatim, never normalize their contents.
         if (!isTriple && afterOpen.startsWith('!')) {
             const isBlock = afterOpen.startsWith('!--');
-            const closeStr = isBlock ? '--}}' : '}}';
-            const close = text.indexOf(closeStr, open + openLen);
+            const closeString = isBlock ? '--}}' : '}}';
+            const close = text.indexOf(closeString, open + openLength);
             if (close === -1) {
                 out += text.slice(open);
                 break;
             }
-            const end = close + closeStr.length;
+            const end = close + closeString.length;
             tokens.push(text.slice(open, end));
             out += `${HANDLEBARS_PH}${tokens.length - 1}END`;
-            i = end;
+            index = end;
             continue;
         }
 
         // Scan for the closing delimiter, ignoring `}}` inside string literals.
         const closeDelim = isTriple ? '}}}' : '}}';
-        /** @type {string|null} */
-        let quote = null;
-        let j = open + openLen;
-        let foundClose = -1;
-        while (j < n) {
-            const ch = text[j];
-            if (quote) {
-                if (ch === quote) {
-                    quote = null;
-                }
-                j++;
-                continue;
-            }
-            if (ch === '"' || ch === "'") {
-                quote = ch;
-                j++;
-                continue;
-            }
-            if (text.startsWith(closeDelim, j)) {
-                foundClose = j;
-                break;
-            }
-            j++;
-        }
+        const foundClose = findClosingDelimiter(text, open + openLength, closeDelim, n);
 
         if (foundClose === -1) {
             // Unbalanced — leave the remainder exactly as-is for the HTML parser.
@@ -314,17 +326,17 @@ function extractHandlebarsRegions(text, opts = {}) {
             break;
         }
 
-        const inner = text.slice(open + openLen, foundClose);
-        const opener = text.slice(open, open + openLen);
+        const inner = text.slice(open + openLength, foundClose);
+        const opener = text.slice(open, open + openLength);
         const normalized = normalizeMustacheInner(inner, { helperCase });
         // Pad simple mustaches (`{{ … }}`) and triple-stache (`{{{ … }}}`) when
         // `spacing` is enabled; sigil mustaches (`{{#…}}`, `{{/…}}`, `{{^…}}`,
         // `{{>…}}`, `{{&…}}`) always stay tight.
         const hasSigil = MUSTACHE_SIGILS.has(normalized[0]);
-        const pad = spacing && !hasSigil && normalized.length > 0 ? ' ' : '';
+        const pad = isSpacing && !hasSigil && normalized.length > 0 ? ' ' : '';
         tokens.push(`${opener}${pad}${normalized}${pad}${closeDelim}`);
         out += `${HANDLEBARS_PH}${tokens.length - 1}END`;
-        i = foundClose + closeDelim.length;
+        index = foundClose + closeDelim.length;
     }
 
     return { html: out, tokens };
@@ -481,9 +493,9 @@ export const printers = {
                             parts.push(d.slice(last, m.index));
                         }
                         if (m[1] === undefined) {
-                            parts.push(handlebarsTokens[Number.parseInt(m[2], 10)]);
+                            parts.push(handlebarsTokens[Number(m[2])]);
                         } else {
-                            parts.push(print(['children', Number.parseInt(m[1], 10)]));
+                            parts.push(print(['children', Number(m[1])]));
                         }
                         last = m.index + m[0].length;
                     }

package/src/printer.js

@@ -36,10 +36,14 @@ function collectVariableMap(node) {
         }
 
         if (Array.isArray(n.children)) {
-            n.children.forEach(walk);
+            for (const child of n.children) {
+                walk(child);
+            }
         }
         if (Array.isArray(n.statements)) {
-            n.statements.forEach(walk);
+            for (const statement of n.statements) {
+                walk(statement);
+            }
         }
         if (n.target) {
             walk(n.target);
@@ -63,13 +67,19 @@ function collectVariableMap(node) {
             walk(n.argument);
         }
         if (Array.isArray(n.arguments)) {
-            n.arguments.forEach(walk);
+            for (const argument of n.arguments) {
+                walk(argument);
+            }
         }
         if (Array.isArray(n.variables)) {
-            n.variables.forEach(walk);
+            for (const variable of n.variables) {
+                walk(variable);
+            }
         }
         if (Array.isArray(n.consequent)) {
-            n.consequent.forEach(walk);
+            for (const consequent of n.consequent) {
+                walk(consequent);
+            }
         }
         if (Array.isArray(n.alternates)) {
             for (const alt of n.alternates) {
@@ -77,12 +87,16 @@ function collectVariableMap(node) {
                     walk(alt.condition);
                 }
                 if (Array.isArray(alt.body)) {
-                    alt.body.forEach(walk);
+                    for (const bodyNode of alt.body) {
+                        walk(bodyNode);
+                    }
                 }
             }
         }
         if (Array.isArray(n.body)) {
-            n.body.forEach(walk);
+            for (const bodyNode of n.body) {
+                walk(bodyNode);
+            }
         }
         if (n.counter) {
             walk(n.counter);
@@ -109,12 +123,8 @@ function isNeedlessParenExpression(node) {
         return false;
     }
     const inner = node.expression;
-    return (
-        inner.type === 'Variable' ||
-        inner.type === 'StringLiteral' ||
-        inner.type === 'NumberLiteral' ||
-        inner.type === 'BooleanLiteral' ||
-        inner.type === 'Identifier'
+    return ['Variable', 'StringLiteral', 'NumberLiteral', 'BooleanLiteral', 'Identifier'].includes(
+        inner.type,
     );
 }
 
@@ -207,7 +217,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 === true;
+    const isBlockLineBreaks = options.ampscriptBlockLineBreaks === true;
 
     function resolveVariable(variableName) {
         if (!enforceCasing) {
@@ -269,7 +279,7 @@ function printAmpscriptNode(path, options, print) {
 
     switch (node.type) {
         case 'Document': {
-            return path.map(print, 'children');
+            return path.map((childPath, index) => print(childPath, index), 'children');
         }
 
         case 'Content': {
@@ -277,17 +287,21 @@ function printAmpscriptNode(path, options, print) {
         }
 
         case 'Block': {
-            const stmts = path.map(print, 'statements');
-            const stmtNodes = node.statements;
+            const statements = path.map(
+                (statementPath, index) => print(statementPath, index),
+                'statements',
+            );
+            const statementNodes = node.statements;
             const body = [];
-            for (const [index, stmt] of stmts.entries()) {
+            for (const [index, statement] of statements.entries()) {
                 if (index > 0) {
                     body.push(hardline);
-                    if (stmtNodes[index] && stmtNodes[index].blankLineBefore) {
+                    const statementNode = statementNodes[index];
+                    if (statementNode && statementNode.blankLineBefore) {
                         body.push(hardline);
                     }
                 }
-                body.push(stmt);
+                body.push(statement);
             }
             const isScriptTag = node.syntax === 'script-tag';
             const blockOpen = isScriptTag ? '<script runat="server" language="ampscript">' : '%%[';
@@ -298,7 +312,7 @@ function printAmpscriptNode(path, options, print) {
                 hardline,
                 blockClose,
             ]);
-            if (blockLineBreaks) {
+            if (isBlockLineBreaks) {
                 const originalText = options.originalText;
                 const parts = [];
                 if (needsLeadingBlockBreak(originalText, node.start)) {
@@ -318,11 +332,11 @@ function printAmpscriptNode(path, options, print) {
         }
 
         case 'InlineExpression': {
-            const expr = print('expression');
+            const expression = print('expression');
             if (enforceSpacing) {
-                return ['%%= ', expr, ' =%%'];
+                return ['%%= ', expression, ' =%%'];
             }
-            return ['%%=', expr, '=%%'];
+            return ['%%=', expression, '=%%'];
         }
 
         case 'Comment': {
@@ -330,7 +344,10 @@ function printAmpscriptNode(path, options, print) {
         }
 
         case 'VarDeclaration': {
-            const variables = path.map(print, 'variables');
+            const variables = path.map(
+                (variablePath, index) => print(variablePath, index),
+                'variables',
+            );
             if (variableStyle === 'multi-line') {
                 return [
                     kw('var', node.originalKeyword),
@@ -367,10 +384,17 @@ function printAmpscriptNode(path, options, print) {
                 group([kw('if', okw.if), ' ', print('condition'), ' ', kw('then', okw.then)]),
             );
             if (node.consequent.length > 0) {
-                parts.push(indent([hardline, join(hardline, path.map(print, 'consequent'))]));
+                const consequentDocuments = path.map(
+                    (consequentPath, index) => print(consequentPath, index),
+                    'consequent',
+                );
+                parts.push(indent([hardline, join(hardline, consequentDocuments)]));
             }
-            const altDocs = path.map(print, 'alternates');
-            for (const altDocument of altDocs) {
+            const altDocuments = path.map(
+                (alternatePath, index) => print(alternatePath, index),
+                'alternates',
+            );
+            for (const altDocument of altDocuments) {
                 parts.push(altDocument);
             }
             // Only emit endif when the parser saw it in this block (cross-block
@@ -395,7 +419,8 @@ function printAmpscriptNode(path, options, print) {
                 ]),
             );
             if (node.body.length > 0) {
-                parts.push(indent([hardline, join(hardline, path.map(print, 'body'))]));
+                const bodyDocuments = path.map((bodyPath, index) => print(bodyPath, index), 'body');
+                parts.push(indent([hardline, join(hardline, bodyDocuments)]));
             }
             return parts;
         }
@@ -405,7 +430,8 @@ function printAmpscriptNode(path, options, print) {
             const parts = [];
             parts.push([hardline, kw('else', akw.else)]);
             if (node.body.length > 0) {
-                parts.push(indent([hardline, join(hardline, path.map(print, 'body'))]));
+                const bodyDocuments = path.map((bodyPath, index) => print(bodyPath, index), 'body');
+                parts.push(indent([hardline, join(hardline, bodyDocuments)]));
             }
             return parts;
         }
@@ -415,7 +441,7 @@ function printAmpscriptNode(path, options, print) {
             const counterDocument = node.counter ? print('counter') : '';
             const startDocument = print('startExpr');
             const endDocument = print('endExpr');
-            const dir = kw(node.direction, okw.direction);
+            const direction = kw(node.direction, okw.direction);
             const parts = [];
             parts.push([
                 kw('for', okw.for),
@@ -424,14 +450,15 @@ function printAmpscriptNode(path, options, print) {
                 ' = ',
                 startDocument,
                 ' ',
-                dir,
+                direction,
                 ' ',
                 endDocument,
                 ' ',
                 kw('do', okw.do),
             ]);
             if (node.body.length > 0) {
-                parts.push(indent([hardline, join(hardline, path.map(print, 'body'))]));
+                const bodyDocuments = path.map((bodyPath, index) => print(bodyPath, index), 'body');
+                parts.push(indent([hardline, join(hardline, bodyDocuments)]));
             }
             // Only emit next when the parser saw it in this block (cross-block
             // FOR/NEXT spans multiple %%[ ]%% segments; missing next is intentional).
@@ -446,7 +473,10 @@ function printAmpscriptNode(path, options, print) {
         }
 
         case 'FunctionCall': {
-            const arguments_ = path.map(print, 'arguments');
+            const arguments_ = path.map(
+                (argumentPath, index) => print(argumentPath, index),
+                'arguments',
+            );
             const functionName = function_(node.name);
             return group([
                 functionName,
@@ -503,15 +533,15 @@ function printAmpscriptNode(path, options, print) {
         }
 
         case 'RawStatement': {
-            const doc = kw(node.value.toLowerCase(), node.keyword);
+            const document = kw(node.value.toLowerCase(), node.keyword);
             const extra = node.crossBlockIndentDepth || 0;
             if (extra === 0) {
-                return doc;
+                return document;
             }
             // Nested `indent()` does not stack visible spaces on single-line string
             // leaves; prefix each line so cross-block ENDIF aligns with its opening IF.
             const oneLevel = options.useTabs ? '\t' : ' '.repeat(options.tabWidth || 4);
-            return [oneLevel.repeat(extra), doc];
+            return [oneLevel.repeat(extra), document];
         }
 
         case 'Raw': {