@salesforce-ux/eslint-plugin-slds 0.0.8 → 0.0.10

package/build/index.js

@@ -12,13 +12,13 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var lib = {exports: {}};
+var lib$1 = {exports: {}};
 
-var parser$1 = {};
+var parser$2 = {};
 
 var dist = {};
 
-var parser = {};
+var parser$1 = {};
 
 var parse = {};
 
@@ -2827,13 +2827,13 @@ function requireParse () {
 	return parse;
 }
 
-var hasRequiredParser$1;
+var hasRequiredParser$2;
 
-function requireParser$1 () {
-	if (hasRequiredParser$1) return parser;
-	hasRequiredParser$1 = 1;
+function requireParser$2 () {
+	if (hasRequiredParser$2) return parser$1;
+	hasRequiredParser$2 = 1;
 	(function (exports) {
-		var __createBinding = (parser && parser.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		var __createBinding = (parser$1 && parser$1.__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)) {
@@ -2844,13 +2844,13 @@ function requireParser$1 () {
 		    if (k2 === undefined) k2 = k;
 		    o[k2] = m[k];
 		}));
-		var __exportStar = (parser && parser.__exportStar) || function(m, exports) {
+		var __exportStar = (parser$1 && parser$1.__exportStar) || function(m, exports) {
 		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		__exportStar(requireParse(), exports); 
-	} (parser));
-	return parser;
+	} (parser$1));
+	return parser$1;
 }
 
 var node$1 = {};
@@ -2886,7 +2886,7 @@ function requireDist () {
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		exports.TokenTypes = exports.NodeTypes = exports.parse = void 0;
-		var parser_1 = requireParser$1();
+		var parser_1 = requireParser$2();
 		Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } });
 		var constants_1 = requireConstants();
 		Object.defineProperty(exports, "NodeTypes", { enumerable: true, get: function () { return constants_1.NodeTypes; } });
@@ -3024,25 +3024,307 @@ function requireTraverse () {
 }
 
 /**
- * @typedef {import("./types").ProgramNode} ProgramNode
+ * @typedef {import("./types").TemplateSyntax} TemplateSyntax
+ * @typedef {import("./types").Range} Range
+ * @typedef {import("./types").OpenSyntax} OpenSyntax
+ * @typedef {import("./types").CloseSyntax} CloseSyntax
+ * @typedef {import("./types").TemplateSyntaxParserResult} TemplateSyntaxParserResult
+ *
+ */
+
+var parser;
+var hasRequiredParser$1;
+
+function requireParser$1 () {
+	if (hasRequiredParser$1) return parser;
+	hasRequiredParser$1 = 1;
+	parser = class Parser {
+	  /**
+	   * @param {string} code
+	   * @param {[string, string][]} syntaxPairs
+	   * @param {Range[]} skipRanges
+	   */
+	  constructor(code, syntaxPairs, skipRanges) {
+	    /**
+	     * @type {string}
+	     */
+	    this.code = code;
+	    /**
+	     * @type {[string, string][]}
+	     */
+	    this.syntaxPairs = syntaxPairs || [];
+	    /**
+	     * @type {Range[]}
+	     */
+	    this.skipRanges = skipRanges;
+	    /**
+	     * @type {OpenSyntax[]}
+	     */
+	    this.syntaxStack = [];
+	    /**
+	     * @type {TemplateSyntax[]}
+	     */
+	    this.result = [];
+	  }
+
+	  /**
+	   * @private
+	   * @param {number} index
+	   * @returns {Range | undefined}
+	   */
+	  findSkipRange(index) {
+	    return this.skipRanges.find(
+	      (range) => range[0] <= index && index < range[1]
+	    );
+	  }
+
+	  /**
+	   * @param {string} syntax
+	   * @param {number} position
+	   * @returns {number}
+	   */
+	  indexOf(syntax, position) {
+	    const index = this.code.indexOf(syntax, position);
+	    if (index < 0) return index;
+	    const skipRange = this.findSkipRange(index);
+	    if (skipRange) {
+	      return this.indexOf(syntax, skipRange[1]);
+	    }
+	    return index;
+	  }
+
+	  /**
+	   * @param {number} position
+	   * @returns {OpenSyntax | null}
+	   */
+	  findOpenSyntax(position) {
+	    /**
+	     * @type {string | null}
+	     */
+	    let value = null;
+	    let rangeStart = Infinity;
+	    for (let i = 0; i < this.syntaxPairs.length; i++) {
+	      const [open] = this.syntaxPairs[i];
+	      const openIndex = this.indexOf(open, position);
+	      if (openIndex >= 0 && openIndex < rangeStart) {
+	        value = open;
+	        rangeStart = openIndex;
+	      }
+	    }
+	    if (!value) return null;
+	    return {
+	      type: "open",
+	      value,
+	      range: [rangeStart, rangeStart + value.length],
+	    };
+	  }
+
+	  /**
+	   * @param {number} position
+	   * @returns {CloseSyntax | null}
+	   */
+	  findCloseSyntax(position) {
+	    /**
+	     * @type {string | null}
+	     */
+	    let value = null;
+	    let rangeStart = Infinity;
+	    for (let i = 0; i < this.syntaxPairs.length; i++) {
+	      const [, close] = this.syntaxPairs[i];
+	      const closeIndex = this.indexOf(close, position);
+	      if (closeIndex >= 0 && closeIndex < rangeStart) {
+	        value = close;
+	        rangeStart = closeIndex;
+	      }
+	    }
+	    if (!value) return null;
+	    return {
+	      type: "close",
+	      value,
+	      range: [rangeStart, rangeStart + value.length],
+	    };
+	  }
+
+	  /**
+	   * @returns {OpenSyntax[]}
+	   */
+	  findAllOpenSyntax() {
+	    /**
+	     * @type {OpenSyntax[]}
+	     */
+	    const result = [];
+	    let position = 0;
+
+	    while (position < this.code.length) {
+	      const openSyntax = this.findOpenSyntax(position);
+	      if (!openSyntax) {
+	        break;
+	      }
+	      result.push(openSyntax);
+	      position = openSyntax.range[1];
+	    }
+
+	    return result;
+	  }
+
+	  /**
+	   * @returns {CloseSyntax[]}
+	   */
+	  findAllCloseSyntax() {
+	    /**
+	     * @type {CloseSyntax[]}
+	     */
+	    const result = [];
+	    let position = 0;
+
+	    while (position < this.code.length) {
+	      const closeSyntax = this.findCloseSyntax(position);
+	      if (!closeSyntax) {
+	        break;
+	      }
+	      result.push(closeSyntax);
+	      position = closeSyntax.range[1];
+	    }
+
+	    return result;
+	  }
+
+	  /**
+	   * @returns {(CloseSyntax | OpenSyntax)[]}
+	   */
+	  findAllSyntax() {
+	    return this.findAllOpenSyntax()
+	      .concat(this.findAllCloseSyntax())
+	      .sort((a, b) => a.range[0] - b.range[0]);
+	  }
+
+	  /**
+	   * @param {OpenSyntax} open
+	   * @returns {string}
+	   */
+	  getPossibleCloseValueOf(open) {
+	    return this.syntaxPairs.find((syntax) => syntax[0] === open.value)[1];
+	  }
+
+	  /**
+	   * @param {CloseSyntax | OpenSyntax} syntax
+	   */
+	  eatSyntax(syntax) {
+	    if (syntax.type === "open") {
+	      const top = this.syntaxStack.pop();
+	      if (!top) {
+	        this.syntaxStack.push(syntax);
+	      } else {
+	        throw new Error(
+	          `Expecting "${this.getPossibleCloseValueOf(top)}", but found "${
+	            syntax.value
+	          }" at (${syntax.range[0]}, ${syntax.range[1]}).`
+	        );
+	      }
+	    } else if (syntax.type === "close") {
+	      const top = this.syntaxStack.pop();
+	      if (!top) {
+	        return;
+	      } else if (this.getPossibleCloseValueOf(top) === syntax.value) {
+	        this.result.push({
+	          open: top.value,
+	          close: syntax.value,
+	          range: [top.range[0], syntax.range[1]],
+	        });
+	      }
+	    }
+	  }
+
+	  /**
+	   * @returns {TemplateSyntaxParserResult}
+	   */
+	  parse() {
+	    for (const syntax of this.findAllSyntax()) {
+	      this.eatSyntax(syntax);
+	    }
+	    return {
+	      syntax: this.result,
+	    };
+	  }
+	};
+	return parser;
+}
+
+/**
+ * @typedef {import("./types").TemplateSyntaxParserConfig} TemplateSyntaxParserConfig
+ */
+
+var templateSyntaxParser;
+var hasRequiredTemplateSyntaxParser;
+
+function requireTemplateSyntaxParser () {
+	if (hasRequiredTemplateSyntaxParser) return templateSyntaxParser;
+	hasRequiredTemplateSyntaxParser = 1;
+	const Parser = requireParser$1();
+
+	/**
+	 * @param {string} code
+	 * @param {TemplateSyntaxParserConfig} config
+	 */
+	function parse(code, config) {
+	  const syntaxPairs = Object.entries(config.syntax) || [];
+	  syntaxPairs.sort((syntaxA, syntaxB) => syntaxB[0].length - syntaxA[0].length);
+	  const parser = new Parser(code, syntaxPairs, config.skipRanges || []);
+	  return parser.parse();
+	}
+
+	templateSyntaxParser = {
+	  parse,
+	};
+	return templateSyntaxParser;
+}
+
+var lib;
+var hasRequiredLib$1;
+
+function requireLib$1 () {
+	if (hasRequiredLib$1) return lib;
+	hasRequiredLib$1 = 1;
+	const { parse } = requireTemplateSyntaxParser();
+	lib = {
+	  parse,
+	};
+	return lib;
+}
+
+/**
+ * @typedef {import("./types").ParserOptions} ParserOptions
  */
 
 var hasRequiredParser;
 
 function requireParser () {
-	if (hasRequiredParser) return parser$1;
+	if (hasRequiredParser) return parser$2;
 	hasRequiredParser = 1;
 	const { parse } = requireDist();
 	const { visitorKeys } = requireVisitorKeys();
 	const { traverse } = requireTraverse();
 	const { NODE_TYPES } = requireNodeTypes();
+	const templateSyntaxParser = requireLib$1();
 
 	/**
 	 * @param {string} code
-	 * @returns {ProgramNode}
+	 * @param {ParserOptions | undefined} parserOptions
+	 * @returns {any}
 	 */
-	parser$1.parseForESLint = function parseForESLint(code) {
-	  const { ast, tokens } = parse(code);
+	parser$2.parseForESLint = function parseForESLint(code, parserOptions) {
+	  const options =
+	    (parserOptions &&
+	      parserOptions.templateEngineSyntax && {
+	        templateRanges: templateSyntaxParser
+	          .parse(code, {
+	            syntax: parserOptions.templateEngineSyntax,
+	          })
+	          .syntax.map((s) => s.range),
+	      }) ||
+	    undefined;
+
+	  const { ast, tokens } = parse(code, options);
 
 	  const programNode = {
 	    type: "Program",
@@ -3075,11 +3357,11 @@ function requireParser () {
 	    scopeManager: null,
 	  };
 	};
-	return parser$1;
+	return parser$2;
 }
 
 var name = "@html-eslint/parser";
-var version = "0.33.0";
+var version = "0.34.0";
 var description = "Parser for @html-eslint/eslint-plugin";
 var author = "yeonjuan";
 var homepage = "https://github.com/yeonjuan/html-eslint#readme";
@@ -3114,12 +3396,13 @@ var bugs = {
 	url: "https://github.com/yeonjuan/html-eslint/issues"
 };
 var dependencies = {
+	"@html-eslint/template-syntax-parser": "^0.34.0",
 	"es-html-parser": "^1.0.0-alpha.4"
 };
 var devDependencies = {
 	typescript: "^5.7.2"
 };
-var gitHead = "4a0ee932a671f8c54bf1a86849fe886e9628b777";
+var gitHead = "f0401cc30d1510d6f5c7511280c0a6b9779fea0c";
 var require$$0 = {
 	name: name,
 	version: version,
@@ -3152,24 +3435,52 @@ function requireMeta () {
 	return meta;
 }
 
+var templateEngineSyntaxPreset;
+var hasRequiredTemplateEngineSyntaxPreset;
+
+function requireTemplateEngineSyntaxPreset () {
+	if (hasRequiredTemplateEngineSyntaxPreset) return templateEngineSyntaxPreset;
+	hasRequiredTemplateEngineSyntaxPreset = 1;
+	const HANDLEBAR = {
+	  "{{": "}}",
+	};
+	const TWIG = {
+	  "{{": "}}",
+	  "{%": "%}",
+	  "{#": "#}",
+	};
+	const ERB = {
+	  "<%": "%>",
+	};
+
+	templateEngineSyntaxPreset = {
+	  HANDLEBAR,
+	  TWIG,
+	  ERB,
+	};
+	return templateEngineSyntaxPreset;
+}
+
 var hasRequiredLib;
 
 function requireLib () {
-	if (hasRequiredLib) return lib.exports;
+	if (hasRequiredLib) return lib$1.exports;
 	hasRequiredLib = 1;
 	const { parseForESLint } = requireParser();
 	const meta = requireMeta();
 	const { NODE_TYPES } = requireNodeTypes();
+	const TEMPLATE_ENGINE_SYNTAX = requireTemplateEngineSyntaxPreset();
 
-	lib.exports.parseForESLint = parseForESLint;
-	lib.exports.NODE_TYPES = NODE_TYPES;
+	lib$1.exports.parseForESLint = parseForESLint;
+	lib$1.exports.NODE_TYPES = NODE_TYPES;
 
-	lib.exports = {
+	lib$1.exports = {
+	  TEMPLATE_ENGINE_SYNTAX,
 	  parseForESLint,
 	  NODE_TYPES,
 	  meta,
 	};
-	return lib.exports;
+	return lib$1.exports;
 }
 
 var node;
@@ -3634,11 +3945,19 @@ function requireModalCloseButtonIssue () {
 
 	      const tagName = node.name;
 
-	      // ✅ Scenario 1: Remove 'slds-button_icon-inverse' from <button>
+	      // ✅ Scenario 1: Remove 'slds-button_icon-inverse' from <button> 
+	      // (optional) when the parent of the button has class name `slds-modal`
+	      // and also button should have class `slds-modal__close`
 	      if (tagName === "button") {
 	        const classAttr = findAttr(node, "class");
 	        if (classAttr && classAttr.value) {
 	          const classList = classAttr.value.value.split(/\s+/);
+
+	          // ✅ Ensure button has "slds-modal__close" before proceeding
+	          if (!classList.includes("slds-modal__close")) {
+	            return; // Stop execution if the class is missing
+	          }
+
 	          if (classList.includes("slds-button_icon-inverse")) {
 	            context.report({
 	              node,
@@ -3657,98 +3976,116 @@ function requireModalCloseButtonIssue () {
 	        }
 	      }
 
-	      // ✅ Scenario 2: Fix <lightning-button-icon>
+	      // ✅ Scenario 2: Fix <lightning-button-icon> and this should have class `slds-modal__close`
 	      if (tagName === "lightning-button-icon" || tagName === "lightning:buttonIcon") {
 	        const variantAttr = findAttr(node, "variant");
 	        const sizeAttr = findAttr(node, "size");
 	        const classAttr = findAttr(node, "class");
 
-	        // Fix variant="bare-inverse" to "bare"
-	        if (variantAttr && variantAttr.value && variantAttr.value.value === "bare-inverse") {
-	          context.report({
-	            node: variantAttr,
-	            messageId: "changeVariant",
-	            fix(fixer) {
-	              return fixer.replaceText(variantAttr.value, `bare`);
-	            },
-	          });
-	        }
-
-	        // Ensure size="large" exists
-	        if (!sizeAttr) {
-	          context.report({
-	            node,
-	            messageId: "ensureSizeAttribute",
-	            fix(fixer) {
-	              //return fixer.insertTextAfter(node, ' size="large"');
-	              return fixer.insertTextAfterRange([variantAttr.range[1], variantAttr.range[1]], ' size="large"')
-	            },
-	          });
-	        }
-
-	        // Ensure 'slds-button' and 'slds-button_icon' are in the class attribute
 	        if (classAttr && classAttr.value) {
 	          const classList = classAttr.value.value.split(/\s+/);
-	          if (!classList.includes("slds-button") || !classList.includes("slds-button_icon")) {
+
+	          // ✅ Ensure button has "slds-modal__close" before proceeding
+	          if (!classList.includes("slds-modal__close")) {
+	            return; // Stop execution if the class is missing
+	          }
+
+	          // Fix variant="bare-inverse" to "bare"
+	          if (variantAttr && variantAttr.value && variantAttr.value.value === "bare-inverse") {
 	            context.report({
-	              node: classAttr,
-	              messageId: "ensureButtonClasses",
+	              node: variantAttr,
+	              messageId: "changeVariant",
 	              fix(fixer) {
-	                const newClassList = [
-	                  "slds-button",
-	                  "slds-button_icon",
-	                  ...classList.filter(
-	                    (cls) => cls !== "slds-button_icon-inverse"
-	                  ),
-	                ].join(" ");
-	                return fixer.replaceText(classAttr.value, `"${newClassList}"`);
+	                return fixer.replaceText(variantAttr.value, `bare`);
 	              },
 	            });
 	          }
+
+	          // Ensure size="large" exists
+	          if (!sizeAttr) {
+	            context.report({
+	              node,
+	              messageId: "ensureSizeAttribute",
+	              fix(fixer) {
+	                //return fixer.insertTextAfter(node, ' size="large"');
+	                return fixer.insertTextAfterRange([variantAttr.range[1], variantAttr.range[1]], ' size="large"')
+	              },
+	            });
+	          }
+
+	          // Ensure 'slds-button' and 'slds-button_icon' are in the class attribute 
+	          if (classAttr && classAttr.value) {
+	            const classList = classAttr.value.value.split(/\s+/);
+	            if (!classList.includes("slds-button") || !classList.includes("slds-button_icon")) {
+	              context.report({
+	                node: classAttr,
+	                messageId: "ensureButtonClasses",
+	                fix(fixer) {
+	                  const newClassList = [
+	                    "slds-button",
+	                    "slds-button_icon",
+	                    ...classList.filter(
+	                      (cls) => cls !== "slds-button_icon-inverse"
+	                    ),
+	                  ].join(" ");
+	                  return fixer.replaceText(classAttr.value, `"${newClassList}"`);
+	                },
+	              });
+	            }
+	          }
 	        }
+
 	      }
 
-	      // ✅ Scenario 3: Fix <lightning-icon> inside <button>
+	      // ✅ Scenario 3: Fix <lightning-icon> inside <button> & the class name of the parent name as button and it should have `slds-modal__close`
 	      if ((tagName === "lightning-icon" || tagName === "lightning:icon") && node.parent?.name === "button") {
-	        const variantAttr = findAttr(node, "variant");
-	        const sizeAttr = findAttr(node, "size");
+	        const parentClassAttr = findAttr(node.parent, "class");
+	        if (parentClassAttr && parentClassAttr.value) {
+	          const parentClassList = parentClassAttr.value.value.split(/\s+/);
 
-	        // Fix variant="bare-inverse" to "bare"
-	        if (variantAttr && variantAttr.value && variantAttr.value.value === "bare-inverse") {
-	          context.report({
-	            node: variantAttr,
-	            messageId: "changeVariant",
-	            fix(fixer) {
-	              return fixer.replaceText(variantAttr.value, `"bare"`);
-	            },
-	          });
-	        }
+	          // ✅ Ensure the parent <button> has "slds-modal__close" before proceeding
+	          if (!parentClassList.includes("slds-modal__close")) {
+	            return; // Stop execution if the class is missing
+	          }
+	          const variantAttr = findAttr(node, "variant");
+	          const sizeAttr = findAttr(node, "size");
 
-	        // Remove variant attribute completely
-	        if (variantAttr) {
-	          context.report({
-	            node: variantAttr,
-	            messageId: "removeVariant",
-	            fix(fixer) {
-	              return fixer.remove(variantAttr);
-	            },
-	          });
-	        }
+	          // Fix variant="bare-inverse" to "bare"
+	          if (variantAttr && variantAttr.value && variantAttr.value.value === "bare-inverse") {
+	            context.report({
+	              node: variantAttr,
+	              messageId: "changeVariant",
+	              fix(fixer) {
+	                return fixer.replaceText(variantAttr.value, `"bare"`);
+	              },
+	            });
+	          }
 
-	        //Ensure size="large" is set
-	        if (!sizeAttr) {
-	          context.report({
-	            node,
-	            messageId: "ensureSizeAttribute",
-	            fix(fixer) {
-	              //return fixer.insertTextAfter(node, ' size="large"');
-	              return fixer.insertTextAfterRange([variantAttr.range[1], variantAttr.range[1]], ' size="large"')
-	            },
-	          });
+	          // Remove variant attribute completely
+	          if (variantAttr) {
+	            context.report({
+	              node: variantAttr,
+	              messageId: "removeVariant",
+	              fix(fixer) {
+	                return fixer.remove(variantAttr);
+	              },
+	            });
+	          }
+
+	          //Ensure size="large" is set
+	          if (!sizeAttr) {
+	            context.report({
+	              node,
+	              messageId: "ensureSizeAttribute",
+	              fix(fixer) {
+	                //return fixer.insertTextAfter(node, ' size="large"');
+	                return fixer.insertTextAfterRange([variantAttr.range[1], variantAttr.range[1]], 'size="large"')
+	              },
+	            });
+	          }
 	        }
 	      }
 	    }
-
 	    return {
 	      Tag: check,
 	    };