eslint-plugin-markdown-preferences 0.32.0 → 0.33.0

package/lib/index.d.ts

@@ -538,7 +538,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.32.0";
+declare const version: "0.33.0";
 //#endregion
 //#region src/language/ast-types.d.ts
 type Node = mdast.Node;

package/lib/index.js

@@ -11278,11 +11278,14 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 		const options = parseOptions(context.options[0]);
 		class TableContext {
 			rows;
+			delimiterRow;
 			columnCount;
-			_cacheHasSpaceBetweenContentAndTrailingPipe = /* @__PURE__ */ new Map();
+			_cacheNeedSpaceBetweenLeadingPipeAndContent = /* @__PURE__ */ new Map();
+			_cacheNeedSpaceBetweenContentAndTrailingPipe = /* @__PURE__ */ new Map();
 			_cacheExpectedPipePosition = /* @__PURE__ */ new Map();
 			constructor(parsed) {
-				const rows = [parsedTableRowToRowData(parsed.headerRow), parsedTableDelimiterRowToRowData(parsed.delimiterRow)];
+				this.delimiterRow = parsedTableDelimiterRowToRowData(parsed.delimiterRow);
+				const rows = [parsedTableRowToRowData(parsed.headerRow), this.delimiterRow];
 				for (const bodyRow of parsed.bodyRows) rows.push(parsedTableRowToRowData(bodyRow));
 				this.rows = rows;
 				let columnCount = 0;
@@ -11300,17 +11303,29 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 				return v;
 			}
 			/**
+			* Check if there is at least one space between leading pipe and content
+			*/
+			isNeedSpaceBetweenLeadingPipeAndContent(pipeIndex) {
+				let v = this._cacheNeedSpaceBetweenLeadingPipeAndContent.get(pipeIndex);
+				if (v != null) return v;
+				if (getCurrentTablePipeSpacingOption(sourceCode)?.leadingSpace === "always") v = true;
+				else v = this._hasSpaceBetweenLeadingPipeAndContentWithoutCache(pipeIndex);
+				this._cacheNeedSpaceBetweenLeadingPipeAndContent.set(pipeIndex, v);
+				return v;
+			}
+			/**
 			* Check if there is at least one space between content and trailing pipe
 			* for the index
 			*
 			* This is used to determine if the pipe should be aligned with a space before it.
 			*/
-			hasSpaceBetweenContentAndTrailingPipe(pipeIndex) {
+			isNeedSpaceBetweenContentAndTrailingPipe(pipeIndex) {
 				if (pipeIndex === 0) return false;
-				let v = this._cacheHasSpaceBetweenContentAndTrailingPipe.get(pipeIndex);
+				let v = this._cacheNeedSpaceBetweenContentAndTrailingPipe.get(pipeIndex);
 				if (v != null) return v;
-				v = this._hasSpaceBetweenContentAndTrailingPipeWithoutCache(pipeIndex);
-				this._cacheHasSpaceBetweenContentAndTrailingPipe.set(pipeIndex, v);
+				if (getCurrentTablePipeSpacingOption(sourceCode)?.trailingSpace === "always") v = true;
+				else v = this._hasSpaceBetweenContentAndTrailingPipeWithoutCache(pipeIndex);
+				this._cacheNeedSpaceBetweenContentAndTrailingPipe.set(pipeIndex, v);
 				return v;
 			}
 			/**
@@ -11321,7 +11336,7 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 					const firstCell = this.rows[0].cells[0];
 					const firstToken = firstCell.leadingPipe ?? firstCell.content;
 					if (!firstToken) return null;
-					return getTextWidth(sourceCode.lines[firstToken.loc.start.line - 1].slice(0, firstToken.loc.start.column - 1));
+					return getTextWidth(sourceCode.lines[firstToken.loc.start.line - 1], 0, firstToken.loc.start.column - 1);
 				}
 				if (options.columnOption === "minimum") return this.getMinimumPipePosition(pipeIndex);
 				else if (options.columnOption === "consistent") {
@@ -11330,7 +11345,7 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 						if (row.cells.length <= columnIndex) continue;
 						const cell = row.cells[columnIndex];
 						if (cell.type === "delimiter" || !cell.trailingPipe) continue;
-						const width = getTextWidth(sourceCode.lines[cell.trailingPipe.loc.start.line - 1].slice(0, cell.trailingPipe.loc.start.column - 1));
+						const width = getTextWidth(sourceCode.lines[cell.trailingPipe.loc.start.line - 1], 0, cell.trailingPipe.loc.start.column - 1);
 						return Math.max(width, this.getMinimumPipePosition(pipeIndex) || 0);
 					}
 				}
@@ -11340,20 +11355,29 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 			* Get the minimum pipe position for the index
 			*/
 			getMinimumPipePosition(pipeIndex) {
-				const spacingRuleOptions = getCurrentTablePipeSpacingOption(sourceCode);
-				const needSpaceBeforePipe = spacingRuleOptions ? spacingRuleOptions.trailingSpace === "always" : this.hasSpaceBetweenContentAndTrailingPipe(pipeIndex);
+				const needSpaceAfterPipe = this.isNeedSpaceBetweenLeadingPipeAndContent(pipeIndex - 1);
+				const needSpaceBeforePipe = this.isNeedSpaceBetweenContentAndTrailingPipe(pipeIndex);
 				let maxWidth = 0;
 				const columnIndex = pipeIndex - 1;
 				for (const row of this.rows) {
 					if (row.cells.length <= columnIndex) continue;
 					const cell = row.cells[columnIndex];
 					let width;
-					if (cell.type === "delimiter") {
+					if (cell.leadingPipe) {
+						const leadingPipeEndOffset = getTextWidth(sourceCode.lines[cell.leadingPipe.loc.end.line - 1], 0, cell.leadingPipe.loc.end.column - 1);
+						let contentLength;
+						if (cell.type === "delimiter") contentLength = getMinimumDelimiterLength(cell.align);
+						else {
+							if (!cell.content) continue;
+							contentLength = getTextWidth(sourceCode.lines[cell.content.loc.start.line - 1], cell.content.loc.start.column - 1, cell.content.loc.end.column - 1);
+						}
+						width = leadingPipeEndOffset + (needSpaceAfterPipe ? 1 : 0) + contentLength;
+					} else if (cell.type === "delimiter") {
 						const minimumDelimiterLength = getMinimumDelimiterLength(cell.align);
-						width = getTextWidth(sourceCode.lines[cell.delimiter.loc.start.line - 1].slice(0, cell.delimiter.loc.start.column - 1)) + minimumDelimiterLength;
+						width = getTextWidth(sourceCode.lines[cell.delimiter.loc.start.line - 1], 0, cell.delimiter.loc.start.column - 1) + minimumDelimiterLength;
 					} else {
 						if (!cell.content) continue;
-						width = getTextWidth(sourceCode.lines[cell.content.loc.end.line - 1].slice(0, cell.content.loc.end.column - 1));
+						width = getTextWidth(sourceCode.lines[cell.content.loc.end.line - 1], 0, cell.content.loc.end.column - 1);
 					}
 					if (needSpaceBeforePipe) width += 1;
 					maxWidth = Math.max(maxWidth, width);
@@ -11361,6 +11385,26 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 				return maxWidth;
 			}
 			/**
+			* Check if there is at least one space between leading pipe and content
+			*/
+			_hasSpaceBetweenLeadingPipeAndContentWithoutCache(pipeIndex) {
+				const columnIndex = pipeIndex;
+				for (const row of this.rows) {
+					if (row.cells.length <= columnIndex) continue;
+					const cell = row.cells[columnIndex];
+					if (!cell.leadingPipe) continue;
+					let content;
+					if (cell.type === "delimiter") content = cell.delimiter;
+					else {
+						if (!cell.content) continue;
+						content = cell.content;
+					}
+					if (cell.leadingPipe.range[1] < content.range[0]) continue;
+					return false;
+				}
+				return true;
+			}
+			/**
 			* Check if there is at least one space between content and trailing pipe
 			*/
 			_hasSpaceBetweenContentAndTrailingPipeWithoutCache(pipeIndex) {
@@ -11413,7 +11457,7 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 		function verifyPipe(pipe, pipeIndex, table, cell) {
 			const expected = table.getExpectedPipePosition(pipeIndex);
 			if (expected == null) return true;
-			const actual = getTextWidth(sourceCode.lines[pipe.loc.start.line - 1].slice(0, pipe.loc.start.column - 1));
+			const actual = getTextWidth(sourceCode.lines[pipe.loc.start.line - 1], 0, pipe.loc.start.column - 1);
 			const diff = expected - actual;
 			if (diff === 0) return true;
 			context.report({
@@ -11436,12 +11480,19 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 					const widthBeforeDelimiter = getTextWidth(beforeDelimiter);
 					const newLength = expected - widthBeforeDelimiter;
 					const minimumDelimiterLength = getMinimumDelimiterLength(cell.align);
-					const spaceAfter = table.hasSpaceBetweenContentAndTrailingPipe(pipeIndex) ? " " : "";
-					if (newLength < minimumDelimiterLength + spaceAfter.length) return null;
+					const spaceAfter = table.isNeedSpaceBetweenContentAndTrailingPipe(pipeIndex) ? " " : "";
+					if (newLength < minimumDelimiterLength + spaceAfter.length) {
+						const edit = fixRemoveSpacesFromLeadingSpaces(Math.abs(newLength - minimumDelimiterLength) + spaceAfter.length);
+						if (!edit) return null;
+						const delimiterPrefix$1 = cell.align === "left" || cell.align === "center" ? ":" : "";
+						const delimiterSuffix$1 = cell.align === "right" || cell.align === "center" ? ":" : "";
+						const newDelimiter$1 = "-".repeat(minimumDelimiterLength - delimiterPrefix$1.length - delimiterSuffix$1.length);
+						return [edit, fixer.replaceTextRange([cell.delimiter.range[0], pipe.range[0]], delimiterPrefix$1 + newDelimiter$1 + delimiterSuffix$1 + spaceAfter)];
+					}
 					const delimiterPrefix = cell.align === "left" || cell.align === "center" ? ":" : "";
-					const delimiterSuffix = (cell.align === "right" || cell.align === "center" ? ":" : "") + spaceAfter;
-					const newDelimiter = "-".repeat(newLength - delimiterPrefix.length - delimiterSuffix.length);
-					return fixer.replaceTextRange([cell.delimiter.range[0], pipe.range[0]], delimiterPrefix + newDelimiter + delimiterSuffix);
+					const delimiterSuffix = cell.align === "right" || cell.align === "center" ? ":" : "";
+					const newDelimiter = "-".repeat(newLength - delimiterPrefix.length - delimiterSuffix.length - spaceAfter.length);
+					return fixer.replaceTextRange([cell.delimiter.range[0], pipe.range[0]], delimiterPrefix + newDelimiter + delimiterSuffix + spaceAfter);
 					/**
 					* Fixer to remove spaces before the pipe
 					*/
@@ -11451,9 +11502,25 @@ var table_pipe_alignment_default = createRule("table-pipe-alignment", {
 						const spacesBeforePipeLength = beforePipe.length - trimmedBeforePipe.length;
 						const widthBeforePipe = getTextWidth(trimmedBeforePipe);
 						const newSpacesLength = expected - widthBeforePipe;
-						if (newSpacesLength < (table.hasSpaceBetweenContentAndTrailingPipe(pipeIndex) ? 1 : 0)) return null;
+						const minTrailingSpaceWidth = table.isNeedSpaceBetweenContentAndTrailingPipe(pipeIndex) ? 1 : 0;
+						if (newSpacesLength < minTrailingSpaceWidth) {
+							const edit = fixRemoveSpacesFromLeadingSpaces(Math.abs(newSpacesLength) + minTrailingSpaceWidth);
+							if (!edit) return null;
+							return [edit, fixer.replaceTextRange([pipe.range[0] - spacesBeforePipeLength, pipe.range[0]], " ".repeat(minTrailingSpaceWidth))];
+						}
 						return fixer.replaceTextRange([pipe.range[0] - spacesBeforePipeLength, pipe.range[0]], " ".repeat(newSpacesLength));
 					}
+					/**
+					* Fixer to remove spaces from the leading spaces
+					*/
+					function fixRemoveSpacesFromLeadingSpaces(removeSpaceLength) {
+						if (!cell.leadingPipe || pipeIndex === 0) return null;
+						const content = cell.type === "delimiter" ? cell.delimiter : cell.content;
+						if (!content) return null;
+						const newSpacesLength = getTextWidth(sourceCode.lines[cell.leadingPipe.loc.end.line - 1], cell.leadingPipe.loc.end.column - 1, content.loc.start.column - 1) - removeSpaceLength;
+						if (newSpacesLength < (table.isNeedSpaceBetweenLeadingPipeAndContent(pipeIndex - 1) ? 1 : 0)) return null;
+						return fixer.replaceTextRange([cell.leadingPipe.range[1], content.range[0]], " ".repeat(newSpacesLength));
+					}
 				}
 			});
 			return false;
@@ -11870,7 +11937,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.32.0";
+const version = "0.33.0";
 
 //#endregion
 //#region src/language/extensions/micromark-custom-container.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {