eslint-plugin-sfmc 2.6.0 → 3.0.0

package/src/rules/ssjs/require-hasownproperty.js

@@ -27,17 +27,17 @@ export default {
             ForInStatement(node) {
                 const body = node.body;
 
-                const stmts = body.type === 'BlockStatement' ? body.body : [body];
+                const statements = body.type === 'BlockStatement' ? body.body : [body];
 
-                if (stmts.length === 0) {
+                if (statements.length === 0) {
                     return;
                 }
 
-                const hasGuard = stmts.some((stmt) => containsHasOwnProperty(stmt));
+                const hasGuard = statements.some((statement) => containsHasOwnProperty(statement));
 
                 if (!hasGuard) {
                     const keyName = getKeyName(node.left);
-                    const objText = context.sourceCode.getText(node.right);
+                    const objectText = context.sourceCode.getText(node.right);
 
                     if (!keyName) {
                         context.report({
@@ -52,43 +52,49 @@ export default {
                         messageId: 'missingGuard',
                         fix(fixer) {
                             const sourceCode = context.sourceCode;
-                            const innerStmts = body.type === 'BlockStatement' ? body.body : [body];
+                            const innerStatements =
+                                body.type === 'BlockStatement' ? body.body : [body];
 
                             // Single-line loops keep compact output to avoid reformatting
                             // code the author intentionally wrote on one line.
                             const isSingleLine = node.loc.start.line === node.loc.end.line;
                             if (isSingleLine) {
-                                const compactBody = innerStmts
-                                    .map((stmt) => sourceCode.getText(stmt))
+                                const compactBody = innerStatements
+                                    .map((statement) => sourceCode.getText(statement))
                                     .join(' ');
                                 return fixer.replaceText(
                                     body,
-                                    `{ if (${objText}.hasOwnProperty(${keyName})) { ${compactBody} } }`,
+                                    `{ if (${objectText}.hasOwnProperty(${keyName})) { ${compactBody} } }`,
                                 );
                             }
 
                             // Multi-line loops: emit a properly-indented guard block.
                             const loopLine = sourceCode.lines[node.loc.start.line - 1] ?? '';
                             const baseIndent = (loopLine.match(/^[\t ]*/) ?? [''])[0];
-                            const firstStmt = innerStmts[0];
-                            const firstStmtLine = firstStmt
-                                ? (sourceCode.lines[firstStmt.loc.start.line - 1] ?? '')
+                            const firstStatement = innerStatements[0];
+                            const firstStatementLine = firstStatement
+                                ? (sourceCode.lines[firstStatement.loc.start.line - 1] ?? '')
                                 : '';
-                            const firstStmtIndent = (firstStmtLine.match(/^[\t ]*/) ?? [''])[0];
+                            const firstStatementIndent = (firstStatementLine.match(/^[\t ]*/) ?? [
+                                '',
+                            ])[0];
                             const unit =
-                                firstStmtIndent.length > baseIndent.length
-                                    ? firstStmtIndent.slice(baseIndent.length)
-                                    : '    ';
+                                firstStatementIndent.length > baseIndent.length
+                                    ? firstStatementIndent.slice(baseIndent.length)
+                                    : ' '.repeat(4);
                             const guardIndent = baseIndent + unit;
-                            const stmtIndent = guardIndent + unit;
+                            const statementIndent = guardIndent + unit;
 
-                            const guardedBody = innerStmts
-                                .map((stmt) => `${stmtIndent}${sourceCode.getText(stmt)}`)
+                            const guardedBody = innerStatements
+                                .map(
+                                    (statement) =>
+                                        `${statementIndent}${sourceCode.getText(statement)}`,
+                                )
                                 .join('\n');
 
                             return fixer.replaceText(
                                 body,
-                                `{\n${guardIndent}if (${objText}.hasOwnProperty(${keyName})) {\n${guardedBody}\n${guardIndent}}\n${baseIndent}}`,
+                                `{\n${guardIndent}if (${objectText}.hasOwnProperty(${keyName})) {\n${guardedBody}\n${guardIndent}}\n${baseIndent}}`,
                             );
                         },
                     });
@@ -99,53 +105,59 @@ export default {
 };
 
 function containsHasOwnProperty(node) {
-    if (!node) {
+    let current = node;
+
+    // Unwrap pass-through single-child nodes iteratively to avoid tail recursion.
+    while (current && current.type === 'ExpressionStatement') {
+        current = current.expression;
+    }
+
+    if (!current) {
         return false;
     }
 
-    if (node.type === 'IfStatement' && node.test && hasOwnPropertyTest(node.test)) {
+    if (current.type === 'IfStatement' && current.test && hasOwnPropertyTest(current.test)) {
         return true;
     }
 
-    if (node.type === 'IfStatement') {
+    if (current.type === 'IfStatement') {
         return (
-            hasOwnPropertyTest(node.test) ||
-            containsHasOwnProperty(node.consequent) ||
-            containsHasOwnProperty(node.alternate)
+            hasOwnPropertyTest(current.test) ||
+            containsHasOwnProperty(current.consequent) ||
+            containsHasOwnProperty(current.alternate)
         );
     }
 
-    if (node.type === 'BlockStatement') {
-        return node.body.some((child) => containsHasOwnProperty(child));
-    }
-
-    if (node.type === 'ExpressionStatement') {
-        return containsHasOwnProperty(node.expression);
+    if (current.type === 'BlockStatement') {
+        return current.body.some((child) => containsHasOwnProperty(child));
     }
 
     return false;
 }
 
 function hasOwnPropertyTest(node) {
-    if (!node) {
+    let current = node;
+
+    // Unwrap negations / unary wrappers iteratively to avoid tail recursion.
+    while (current && current.type === 'UnaryExpression') {
+        current = current.argument;
+    }
+
+    if (!current) {
         return false;
     }
 
     if (
-        node.type === 'CallExpression' &&
-        node.callee.type === 'MemberExpression' &&
-        node.callee.property.type === 'Identifier' &&
-        node.callee.property.name === 'hasOwnProperty'
+        current.type === 'CallExpression' &&
+        current.callee.type === 'MemberExpression' &&
+        current.callee.property.type === 'Identifier' &&
+        current.callee.property.name === 'hasOwnProperty'
     ) {
         return true;
     }
 
-    if (node.type === 'LogicalExpression') {
-        return hasOwnPropertyTest(node.left) || hasOwnPropertyTest(node.right);
-    }
-
-    if (node.type === 'UnaryExpression') {
-        return hasOwnPropertyTest(node.argument);
+    if (current.type === 'LogicalExpression') {
+        return hasOwnPropertyTest(current.left) || hasOwnPropertyTest(current.right);
     }
 
     return false;

package/src/rules/ssjs/require-platform-load-order.js

@@ -8,7 +8,7 @@
 
 import { coreObjectNames } from 'ssjs-data';
 
-const TOP_LEVEL_CORE_NAMES = new Set([...coreObjectNames].map((n) => n.split('.')[0]));
+const TOP_LEVEL_CORE_NAMES = new Set([...coreObjectNames].map((n) => n.split('.', 1)[0]));
 
 export default {
     meta: {

package/src/rules/ssjs/require-platform-load.js

@@ -12,11 +12,11 @@
 
 import { coreObjectNames, SSJS_GLOBALS } from 'ssjs-data';
 
-const TOP_LEVEL_CORE_NAMES = new Set([...coreObjectNames].map((n) => n.split('.')[0]));
+const TOP_LEVEL_CORE_NAMES = new Set([...coreObjectNames].map((n) => n.split('.', 1)[0]));
 
 // Globals that resolve at runtime only after Platform.Load("core", ...) has been called.
 // E.g. Now(), Write(), GUID(), Base64Encode(), Attribute.GetValue(), DateTime.Parse(), …
-const REQUIRES_CORE_LOAD_GLOBALS = new Set(
+const CORE_LOAD_DEPENDENT_GLOBALS = new Set(
     SSJS_GLOBALS.filter((g) => g.requiresCoreLoad).map((g) => g.name.toLowerCase()),
 );
 
@@ -55,7 +55,7 @@ export default {
 
             'Program:exit'() {
                 if (!hasPlatformLoad) {
-                    for (const [i, { node, name }] of pendingReports.entries()) {
+                    for (const [index, { node, name }] of pendingReports.entries()) {
                         context.report({
                             node,
                             messageId: 'missingLoad',
@@ -63,7 +63,7 @@ export default {
                             // Only attach the fix to the first violation to prevent
                             // ESLint from inserting the statement multiple times.
                             fix:
-                                i === 0
+                                index === 0
                                     ? (fixer) =>
                                           fixer.insertTextBeforeRange(
                                               [0, 0],
@@ -105,7 +105,7 @@ function getCoreObjectUsage(node) {
 
     // Bare call: Now(), Write(), GUID(), Base64Encode(), Redirect(), …
     if (callee.type === 'Identifier') {
-        if (REQUIRES_CORE_LOAD_GLOBALS.has(callee.name.toLowerCase())) {
+        if (CORE_LOAD_DEPENDENT_GLOBALS.has(callee.name.toLowerCase())) {
             return callee.name;
         }
         return null;
@@ -135,7 +135,7 @@ function getCoreObjectUsage(node) {
         }
 
         // requiresCoreLoad globals used as object: Attribute.GetValue(…), DateTime.Parse(…), …
-        if (REQUIRES_CORE_LOAD_GLOBALS.has(objectName.toLowerCase())) {
+        if (CORE_LOAD_DEPENDENT_GLOBALS.has(objectName.toLowerCase())) {
             return `${objectName}.${callee.property.name}`;
         }
     }

package/src/rules/ssjs/{ssjs-arg-types.js → ssjs-argument-types.js}

@@ -61,34 +61,34 @@ export default {
     },
 
     create(context) {
-        const coreVars = new Map(); // varName → className (Core Library instances)
-        const wsproxyVars = new Set(); // varNames assigned new Script.Util.WSProxy()
+        const coreVariables = new Map(); // varName → className (Core Library instances)
+        const wsproxyVariables = new Set(); // varNames assigned new Script.Util.WSProxy()
 
-        function checkArgs(entry, args, callName) {
+        function checkArguments(entry, arguments_, callName) {
             if (!entry || !entry.params || entry.params.length === 0) {
                 return;
             }
-            for (const [i, arg] of args.entries()) {
-                const param = entry.params[i];
-                if (!param) {
+            for (const [index, argument] of arguments_.entries()) {
+                const parameter = entry.params[index];
+                if (!parameter) {
                     break;
                 } // beyond declared params — arity rule handles this
-                if (!param.type || param.type === 'any') {
+                if (!parameter.type || parameter.type === 'any') {
                     continue;
                 }
-                const actual = inferArgType(arg);
+                const actual = inferArgumentType(argument);
                 if (actual === null) {
                     continue;
                 } // unknown type (variable/call) — skip
-                if (!isTypeCompatible(actual, param.type)) {
+                if (!isTypeCompatible(actual, parameter.type)) {
                     context.report({
-                        node: arg,
+                        node: argument,
                         messageId: 'typeMismatch',
                         data: {
-                            pos: String(i + 1),
-                            param: param.name,
+                            pos: String(index + 1),
+                            param: parameter.name,
                             call: callName,
-                            expected: param.type,
+                            expected: parameter.type,
                             actual,
                         },
                     });
@@ -98,17 +98,21 @@ export default {
 
         return {
             VariableDeclaration(node) {
-                for (const decl of node.declarations) {
-                    if (!decl.init || !decl.id || decl.id.type !== 'Identifier') {
+                for (const declaration of node.declarations) {
+                    if (
+                        !declaration.init ||
+                        !declaration.id ||
+                        declaration.id.type !== 'Identifier'
+                    ) {
                         continue;
                     }
-                    if (isWSProxyConstructor(decl.init)) {
-                        wsproxyVars.add(decl.id.name);
+                    if (isWSProxyConstructor(declaration.init)) {
+                        wsproxyVariables.add(declaration.id.name);
                         continue;
                     }
-                    const coreType = getCoreInitType(decl.init);
+                    const coreType = getCoreInitType(declaration.init);
                     if (coreType) {
-                        coreVars.set(decl.id.name, coreType);
+                        coreVariables.set(declaration.id.name, coreType);
                     }
                 }
             },
@@ -118,12 +122,12 @@ export default {
                     return;
                 }
                 if (isWSProxyConstructor(node.right)) {
-                    wsproxyVars.add(node.left.name);
+                    wsproxyVariables.add(node.left.name);
                     return;
                 }
                 const coreType = getCoreInitType(node.right);
                 if (coreType) {
-                    coreVars.set(node.left.name, coreType);
+                    coreVariables.set(node.left.name, coreType);
                 }
             },
 
@@ -134,7 +138,7 @@ export default {
                 if (callee.type === 'Identifier') {
                     const entry = ssjsGlobalsLookup.get(callee.name.toLowerCase());
                     if (entry) {
-                        checkArgs(entry, node.arguments, callee.name);
+                        checkArguments(entry, node.arguments, callee.name);
                     }
                     return;
                 }
@@ -159,7 +163,7 @@ export default {
                     if (lookup) {
                         const entry = lookup.get(methodName.toLowerCase());
                         if (entry) {
-                            checkArgs(
+                            checkArguments(
                                 entry,
                                 node.arguments,
                                 `Platform.${callee.object.property.name}.${methodName}`,
@@ -170,48 +174,52 @@ export default {
                 }
 
                 if (callee.object.type === 'Identifier') {
-                    const objName = callee.object.name;
-                    const objLower = objName.toLowerCase();
+                    const objectName = callee.object.name;
+                    const objectLower = objectName.toLowerCase();
 
                     // Static top-level: HTTP.Post(...), HTTPHeader.SetValue(...), Attribute.GetValue(...)
-                    const topLookup = TOPLEVEL_LOOKUPS.get(objLower);
+                    const topLookup = TOPLEVEL_LOOKUPS.get(objectLower);
                     if (topLookup) {
                         const entry = topLookup.get(methodName.toLowerCase());
                         if (entry) {
-                            checkArgs(entry, node.arguments, `${objName}.${methodName}`);
+                            checkArguments(entry, node.arguments, `${objectName}.${methodName}`);
                         }
                         return;
                     }
 
                     // WSProxy instance method: proxy.Retrieve(...)
-                    if (wsproxyVars.has(objName)) {
+                    if (wsproxyVariables.has(objectName)) {
                         const entry = wsproxyMethodLookup.get(methodName.toLowerCase());
                         if (entry) {
-                            checkArgs(entry, node.arguments, `WSProxy.${methodName}`);
+                            checkArguments(entry, node.arguments, `WSProxy.${methodName}`);
                         }
                         return;
                     }
 
                     // Core Library instance method: de.Add(...)
-                    const coreType = coreVars.get(objName);
+                    const coreType = coreVariables.get(objectName);
                     if (coreType) {
                         const classLookup = coreMethodArityLookup.get(coreType.toLowerCase());
                         if (classLookup) {
                             const entry = classLookup.get(methodName.toLowerCase());
                             if (entry) {
-                                checkArgs(entry, node.arguments, `${coreType}.${methodName}`);
+                                checkArguments(entry, node.arguments, `${coreType}.${methodName}`);
                             }
                         }
                         return;
                     }
 
                     // Static Core Library single-name: DataExtension.Init(...), BounceEvent.Retrieve(...)
-                    if (coreObjectNames.has(objName)) {
-                        const classLookup = coreMethodArityLookup.get(objLower);
+                    if (coreObjectNames.has(objectName)) {
+                        const classLookup = coreMethodArityLookup.get(objectLower);
                         if (classLookup) {
                             const entry = classLookup.get(methodName.toLowerCase());
                             if (entry) {
-                                checkArgs(entry, node.arguments, `${objName}.${methodName}`);
+                                checkArguments(
+                                    entry,
+                                    node.arguments,
+                                    `${objectName}.${methodName}`,
+                                );
                             }
                         }
                     }
@@ -225,7 +233,7 @@ export default {
                     if (classLookup) {
                         const entry = classLookup.get(methodName.toLowerCase());
                         if (entry) {
-                            checkArgs(entry, node.arguments, `${objectPath}.${methodName}`);
+                            checkArguments(entry, node.arguments, `${objectPath}.${methodName}`);
                         }
                     }
                 }
@@ -266,13 +274,13 @@ function getMemberPath(node) {
         return node.name;
     }
     if (node.type === 'MemberExpression' && node.property.type === 'Identifier') {
-        const obj = getMemberPath(node.object);
-        return obj ? `${obj}.${node.property.name}` : null;
+        const object = getMemberPath(node.object);
+        return object ? `${object}.${node.property.name}` : null;
     }
     return null;
 }
 
-function inferArgType(node) {
+function inferArgumentType(node) {
     if (!node || node.type === 'SpreadElement') {
         return null;
     }
@@ -294,14 +302,22 @@ function inferArgType(node) {
         return 'string';
     }
     if (node.type === 'ArrayExpression') {
-        const elems = node.elements.filter(Boolean);
-        if (elems.length === 0) {
+        const elements = node.elements.filter(Boolean);
+        if (elements.length === 0) {
             return 'array';
         }
-        if (elems.every((e) => e.type === 'Literal' && typeof e.value === 'string')) {
+        if (
+            elements.every(
+                (element) => element.type === 'Literal' && typeof element.value === 'string',
+            )
+        ) {
             return 'string[]';
         }
-        if (elems.every((e) => e.type === 'Literal' && typeof e.value === 'number')) {
+        if (
+            elements.every(
+                (element) => element.type === 'Literal' && typeof element.value === 'number',
+            )
+        ) {
             return 'number[]';
         }
         return 'array';
@@ -321,10 +337,7 @@ function isTypeCompatible(actual, expected) {
         return true;
     }
     // 'array' is compatible with typed array variants
-    if (allowed.includes('array') && (actual === 'string[]' || actual === 'number[]')) {
-        return true;
-    }
-    return false;
+    return Boolean(allowed.includes('array') && (actual === 'string[]' || actual === 'number[]'));
 }
 
 function isWSProxyConstructor(node) {

package/src/rules/ssjs/ssjs-core-method-arity.js

@@ -28,13 +28,13 @@ export default {
     },
 
     create(context) {
-        const coreVars = new Map(); // varName → className
+        const coreVariables = new Map(); // varName → className
 
-        function checkArity(entry, args, callName, reportNode) {
+        function checkArity(entry, arguments_, callName, reportNode) {
             if (!entry) {
                 return;
             }
-            const actual = args.length;
+            const actual = arguments_.length;
             if (actual < entry.minArgs) {
                 context.report({
                     node: reportNode,
@@ -52,13 +52,17 @@ export default {
 
         return {
             VariableDeclaration(node) {
-                for (const decl of node.declarations) {
-                    if (!decl.init || !decl.id || decl.id.type !== 'Identifier') {
+                for (const declaration of node.declarations) {
+                    if (
+                        !declaration.init ||
+                        !declaration.id ||
+                        declaration.id.type !== 'Identifier'
+                    ) {
                         continue;
                     }
-                    const coreType = getCoreInitType(decl.init);
+                    const coreType = getCoreInitType(declaration.init);
                     if (coreType) {
-                        coreVars.set(decl.id.name, coreType);
+                        coreVariables.set(declaration.id.name, coreType);
                     }
                 }
             },
@@ -69,7 +73,7 @@ export default {
                 }
                 const coreType = getCoreInitType(node.right);
                 if (coreType) {
-                    coreVars.set(node.left.name, coreType);
+                    coreVariables.set(node.left.name, coreType);
                 }
             },
 
@@ -84,10 +88,10 @@ export default {
                 const methodName = callee.property.name;
 
                 if (callee.object.type === 'Identifier') {
-                    const objName = callee.object.name;
+                    const objectName = callee.object.name;
 
                     // Core Library instance method: de.Add(...)
-                    const coreType = coreVars.get(objName);
+                    const coreType = coreVariables.get(objectName);
                     if (coreType) {
                         const classLookup = coreMethodArityLookup.get(coreType.toLowerCase());
                         if (classLookup) {
@@ -103,14 +107,14 @@ export default {
                     }
 
                     // Static single-name: DataExtension.Init(...), BounceEvent.Retrieve(...)
-                    if (coreObjectNames.has(objName)) {
-                        const classLookup = coreMethodArityLookup.get(objName.toLowerCase());
+                    if (coreObjectNames.has(objectName)) {
+                        const classLookup = coreMethodArityLookup.get(objectName.toLowerCase());
                         if (classLookup) {
                             const entry = classLookup.get(methodName.toLowerCase());
                             checkArity(
                                 entry,
                                 node.arguments,
-                                `${objName}.${methodName}`,
+                                `${objectName}.${methodName}`,
                                 callee.property,
                             );
                         }
@@ -169,8 +173,8 @@ function getMemberPath(node) {
         return node.name;
     }
     if (node.type === 'MemberExpression' && node.property.type === 'Identifier') {
-        const obj = getMemberPath(node.object);
-        return obj ? `${obj}.${node.property.name}` : null;
+        const object = getMemberPath(node.object);
+        return object ? `${object}.${node.property.name}` : null;
     }
     return null;
 }