eslint-plugin-hyoban 0.13.2 → 0.14.0

package/dist/index.d.mts

@@ -32,9 +32,6 @@ declare const _default: {
         'i18n-flat-key': RuleModule<[]>;
         'jsonc-inline-spacing': RuleModule<[]>;
         'jsx-attribute-spacing': RuleModule<[]>;
-        'md-consistent-table-width': _eslint_markdown.MarkdownRuleDefinition<{
-            MessageIds: "formatCell";
-        }>;
         'md-one-sentence-per-line': _eslint_markdown.MarkdownRuleDefinition<{
             MessageIds: "wrapParagraph";
         }>;

package/dist/index.mjs

@@ -1,6 +1,4 @@
-import stringWidth from 'fast-string-width';
-
-var version = "0.13.2";
+var version = "0.14.0";
 
 const hasDocs = new Set([
     'prefer-tailwind-icons'
@@ -67,7 +65,7 @@ function getReportNode(sourceCode, targetNode) {
     if (reportNode) return reportNode;
     return sourceCode.ast;
 }
-const rule$7 = createEslintRule({
+const rule$6 = createEslintRule({
     name: 'i18n-flat-key',
     meta: {
         type: 'problem',
@@ -150,7 +148,7 @@ function getCorrectedSource(value) {
         return `{ ${value.properties.filter((property)=>property.key.type !== 'JSONIdentifier').map((property)=>`${property.key.raw}: ${getCorrectedSource(property.value)}`).join(', ')} }`;
     }
 }
-const rule$6 = createEslintRule({
+const rule$5 = createEslintRule({
     name: 'jsonc-inline-spacing',
     meta: {
         type: 'layout',
@@ -212,7 +210,7 @@ const expressionTypesNoCheck = new Set([
     'JSXElement',
     'TSAsExpression'
 ]);
-const rule$5 = createEslintRule({
+const rule$4 = createEslintRule({
     name: 'jsx-attribute-spacing',
     meta: {
         type: 'layout',
@@ -285,293 +283,6 @@ const rule$5 = createEslintRule({
     }
 });
 
-function getCellText(cell, sourceCode) {
-    if (cell.children.length === 0) return '';
-    const firstChild = cell.children[0];
-    const lastChild = cell.children.at(-1);
-    const [start] = sourceCode.getRange(firstChild);
-    const [, end] = sourceCode.getRange(lastChild);
-    return sourceCode.getText().slice(start, end).trim();
-}
-function getDelimiterCell(width, alignment) {
-    if (alignment === 'left') return `:${'-'.repeat(width - 1)}`;
-    if (alignment === 'right') return `${'-'.repeat(width - 1)}:`;
-    if (alignment === 'center') return `:${'-'.repeat(width - 2)}:`;
-    return '-'.repeat(width);
-}
-function getAlignedCellContent(cellText, width, alignment) {
-    const paddingLength = Math.max(0, width - stringWidth(cellText));
-    if (alignment === 'right') return `${' '.repeat(paddingLength)}${cellText}`;
-    if (alignment === 'center') {
-        const leftPaddingLength = Math.floor(paddingLength / 2);
-        const rightPaddingLength = paddingLength - leftPaddingLength;
-        return `${' '.repeat(leftPaddingLength)}${cellText}${' '.repeat(rightPaddingLength)}`;
-    }
-    return `${cellText}${' '.repeat(paddingLength)}`;
-}
-function normalizeAlignments(alignments, columnCount) {
-    return Array.from({
-        length: columnCount
-    }, (_, index)=>alignments?.[index] ?? null);
-}
-function buildTableState(tableNode) {
-    if (tableNode.children.length === 0) return null;
-    const columnCount = Math.max(tableNode.align?.length ?? 0, ...tableNode.children.map((row)=>row.children.length));
-    if (columnCount === 0) return null;
-    const rowValues = tableNode.children.map(()=>Array.from({
-            length: columnCount
-        }, ()=>''));
-    const widths = Array.from({
-        length: columnCount
-    }, ()=>3);
-    const rowIndexByNode = new WeakMap();
-    for (const [index, rowNode] of tableNode.children.entries())rowIndexByNode.set(rowNode, index);
-    return {
-        tableNode,
-        columnCount,
-        rowNodes: tableNode.children,
-        rowValues,
-        widths,
-        alignments: normalizeAlignments(tableNode.align, columnCount),
-        rowIndexByNode,
-        visitedCells: []
-    };
-}
-function formatTableCellSegment(content, columnIndex, columnCount) {
-    const suffix = columnIndex === columnCount - 1 ? ' |' : ' ';
-    return `| ${content}${suffix}`;
-}
-function getExpectedCellSegment(cellText, width, alignment, columnIndex, columnCount) {
-    return formatTableCellSegment(getAlignedCellContent(cellText, width, alignment), columnIndex, columnCount);
-}
-function getExpectedDelimiterSegment(width, alignment, columnIndex, columnCount) {
-    return formatTableCellSegment(getDelimiterCell(width, alignment), columnIndex, columnCount);
-}
-function getExpectedBodyTail(state, rowIndex, startColumnIndex) {
-    if (startColumnIndex >= state.columnCount) return '';
-    return Array.from({
-        length: state.columnCount - startColumnIndex
-    }, (_, index)=>{
-        const columnIndex = startColumnIndex + index;
-        return getExpectedCellSegment(state.rowValues[rowIndex]?.[columnIndex] ?? '', state.widths[columnIndex] ?? 3, state.alignments[columnIndex] ?? null, columnIndex, state.columnCount);
-    }).join('');
-}
-function getExpectedDelimiterTail(state, startColumnIndex) {
-    if (startColumnIndex >= state.columnCount) return '';
-    return Array.from({
-        length: state.columnCount - startColumnIndex
-    }, (_, index)=>{
-        const columnIndex = startColumnIndex + index;
-        return getExpectedDelimiterSegment(state.widths[columnIndex] ?? 3, state.alignments[columnIndex] ?? null, columnIndex, state.columnCount);
-    }).join('');
-}
-function getBodyCellLabel(rowIndex, columnIndex, existingCellCount, columnCount, hasTail) {
-    if (!hasTail || existingCellCount === columnCount) return `R${rowIndex + 1}C${columnIndex + 1}`;
-    return `R${rowIndex + 1}C${columnIndex + 1}-C${columnCount}`;
-}
-function getMissingBodyCellLabel(rowIndex, startColumnIndex, columnCount) {
-    return `R${rowIndex + 1}C${startColumnIndex + 1}-C${columnCount}`;
-}
-function getDelimiterCellLabel(columnIndex, columnCount, hasTail) {
-    if (!hasTail) return `D${columnIndex + 1}`;
-    return `D${columnIndex + 1}-D${columnCount}`;
-}
-function toMessageValue(text) {
-    return JSON.stringify(text);
-}
-function toEditableChange(range, actualSegment, expectedSegment) {
-    const hasLeadingPipe = actualSegment.startsWith('|');
-    return {
-        range: [
-            range[0] + (hasLeadingPipe ? 1 : 0),
-            range[1]
-        ],
-        actual: hasLeadingPipe ? actualSegment.slice(1) : actualSegment,
-        expected: hasLeadingPipe ? expectedSegment.slice(1) : expectedSegment
-    };
-}
-function isTableRow(node) {
-    return !!node && typeof node === 'object' && node.type === 'tableRow';
-}
-function parseRowSegments(rowText, rowStartOffset) {
-    if (rowText.length === 0) return [];
-    const separators = [];
-    for(let index = 1; index < rowText.length - 1; index++){
-        if (rowText[index] === '|') separators.push(index);
-    }
-    const segments = [];
-    let start = 0;
-    for (const separator of separators){
-        segments.push({
-            range: [
-                rowStartOffset + start,
-                rowStartOffset + separator
-            ],
-            text: rowText.slice(start, separator)
-        });
-        start = separator;
-    }
-    segments.push({
-        range: [
-            rowStartOffset + start,
-            rowStartOffset + rowText.length
-        ],
-        text: rowText.slice(start)
-    });
-    return segments;
-}
-function getDelimiterRowSegments(tableNode, sourceCode) {
-    const headerRow = tableNode.children[0];
-    if (!headerRow) return null;
-    const delimiterLine = headerRow.position?.end.line ? headerRow.position.end.line + 1 : null;
-    if (delimiterLine == null) return null;
-    const [tableStartOffset] = sourceCode.getRange(tableNode);
-    const tableStartLoc = sourceCode.getLocFromIndex(tableStartOffset);
-    const originLoc = sourceCode.getLocFromIndex(0);
-    const lineBase = originLoc.line === 0 ? 0 : 1;
-    const columnBase = originLoc.column === 0 ? 0 : 1;
-    const delimiterLineIndex = delimiterLine - lineBase;
-    const fullDelimiterLine = sourceCode.lines[delimiterLineIndex];
-    if (fullDelimiterLine == null) return null;
-    const prefixLength = Math.max(0, tableStartLoc.column - columnBase);
-    const delimiterRowText = fullDelimiterLine.slice(prefixLength);
-    const rowStartOffset = sourceCode.getIndexFromLoc({
-        line: delimiterLine,
-        column: tableStartLoc.column
-    });
-    return {
-        segments: parseRowSegments(delimiterRowText, rowStartOffset),
-        rowEndOffset: rowStartOffset + delimiterRowText.length
-    };
-}
-const rule$4 = {
-    meta: {
-        type: 'layout',
-        docs: {
-            description: 'Format GFM markdown tables to aligned columns',
-            url: 'https://github.com/hyoban/eslint-plugin-hyoban/blob/main/src/md-consistent-table-width.test.ts'
-        },
-        fixable: 'whitespace',
-        schema: [],
-        defaultOptions: [],
-        messages: {
-            formatCell: 'Expected {{cell}} to be {{expected}}, but found {{actual}}.'
-        },
-        language: 'markdown',
-        dialects: [
-            'gfm'
-        ]
-    },
-    create (context) {
-        const { sourceCode } = context;
-        const tableStack = [];
-        function reportFormatCell(range, cell, actual, expected) {
-            if (actual === expected) return;
-            context.report({
-                loc: {
-                    start: sourceCode.getLocFromIndex(range[0]),
-                    end: sourceCode.getLocFromIndex(range[1])
-                },
-                messageId: 'formatCell',
-                data: {
-                    cell,
-                    expected: toMessageValue(expected),
-                    actual: toMessageValue(actual)
-                },
-                fix (fixer) {
-                    return fixer.replaceTextRange(range, expected);
-                }
-            });
-        }
-        return {
-            table (tableNode) {
-                tableStack.push({
-                    tableNode,
-                    state: buildTableState(tableNode)
-                });
-            },
-            tableCell (cellNode) {
-                const current = tableStack.at(-1);
-                const state = current?.state;
-                if (!state) return;
-                const rowNode = sourceCode.getParent(cellNode);
-                if (!isTableRow(rowNode)) return;
-                const rowIndex = state.rowIndexByNode.get(rowNode);
-                if (rowIndex == null) return;
-                const columnIndex = rowNode.children.indexOf(cellNode);
-                if (columnIndex < 0 || columnIndex >= state.columnCount) return;
-                const cellText = getCellText(cellNode, sourceCode);
-                state.rowValues[rowIndex][columnIndex] = cellText;
-                state.widths[columnIndex] = Math.max(state.widths[columnIndex] ?? 3, stringWidth(cellText), 3);
-                state.visitedCells.push({
-                    range: sourceCode.getRange(cellNode),
-                    rowIndex,
-                    columnIndex,
-                    actual: sourceCode.getText(cellNode)
-                });
-            },
-            'table:exit': function(tableNode) {
-                const current = tableStack.pop();
-                if (!current || current.tableNode !== tableNode || !current.state) return;
-                const state = current.state;
-                state.visitedCells.sort((left, right)=>left.range[0] - right.range[0]);
-                const rowTailByRowIndex = new Map();
-                for (const [rowIndex, rowNode] of state.rowNodes.entries()){
-                    const existingCellCount = rowNode.children.length;
-                    if (existingCellCount >= state.columnCount) continue;
-                    const expectedTail = getExpectedBodyTail(state, rowIndex, existingCellCount);
-                    if (expectedTail.length === 0) continue;
-                    if (existingCellCount > 0) {
-                        rowTailByRowIndex.set(rowIndex, expectedTail);
-                        continue;
-                    }
-                    const [, rowEndOffset] = sourceCode.getRange(rowNode);
-                    const missingCellLabel = getMissingBodyCellLabel(rowIndex, existingCellCount, state.columnCount);
-                    reportFormatCell([
-                        rowEndOffset,
-                        rowEndOffset
-                    ], missingCellLabel, '', expectedTail);
-                }
-                for (const cell of state.visitedCells){
-                    const rowNode = state.rowNodes[cell.rowIndex];
-                    const existingCellCount = rowNode?.children.length ?? 0;
-                    const isLastExistingCell = existingCellCount > 0 && cell.columnIndex === existingCellCount - 1;
-                    const rowTail = isLastExistingCell ? rowTailByRowIndex.get(cell.rowIndex) ?? '' : '';
-                    let expected = getExpectedCellSegment(state.rowValues[cell.rowIndex]?.[cell.columnIndex] ?? '', state.widths[cell.columnIndex] ?? 3, state.alignments[cell.columnIndex] ?? null, cell.columnIndex, state.columnCount);
-                    if (rowTail) expected += rowTail;
-                    const change = toEditableChange(cell.range, cell.actual, expected);
-                    if (change.actual === change.expected) continue;
-                    const cellLabel = getBodyCellLabel(cell.rowIndex, cell.columnIndex, existingCellCount, state.columnCount, !!rowTail);
-                    reportFormatCell(change.range, cellLabel, change.actual, change.expected);
-                }
-                const delimiterRow = getDelimiterRowSegments(state.tableNode, sourceCode);
-                if (!delimiterRow) return;
-                const delimiterTail = getExpectedDelimiterTail(state, delimiterRow.segments.length);
-                if (delimiterRow.segments.length === 0) {
-                    if (!delimiterTail) return;
-                    reportFormatCell([
-                        delimiterRow.rowEndOffset,
-                        delimiterRow.rowEndOffset
-                    ], `D1-D${state.columnCount}`, '', delimiterTail);
-                    return;
-                }
-                const delimiterColumnCount = Math.min(state.columnCount, delimiterRow.segments.length);
-                for(let columnIndex = 0; columnIndex < delimiterColumnCount; columnIndex++){
-                    const segment = delimiterRow.segments[columnIndex];
-                    if (!segment) continue;
-                    const isLastExistingDelimiterCell = columnIndex === delimiterRow.segments.length - 1;
-                    let expected = getExpectedDelimiterSegment(state.widths[columnIndex] ?? 3, state.alignments[columnIndex] ?? null, columnIndex, state.columnCount);
-                    if (isLastExistingDelimiterCell && delimiterTail) expected += delimiterTail;
-                    const change = toEditableChange(segment.range, segment.text, expected);
-                    if (change.actual === change.expected) continue;
-                    const cellLabel = getDelimiterCellLabel(columnIndex, state.columnCount, isLastExistingDelimiterCell && !!delimiterTail);
-                    reportFormatCell(change.range, cellLabel, change.actual, change.expected);
-                }
-            }
-        };
-    }
-};
-
 function lastNonWhitespaceChar(segment, segmentStart) {
     for(let i = segment.length - 1; i >= 0; i--){
         const char = segment[i];
@@ -589,7 +300,7 @@ const rule$3 = {
         type: 'layout',
         docs: {
             description: 'Wrap markdown paragraphs so each sentence is on its own line',
-            url: 'https://github.com/hyoban/eslint-plugin-hyoban/blob/main/src/md-one-sentence-per-line.test.ts'
+            url: 'https://github.com/hyoban/eslint-plugin-hyoban/blob/main/src/md-one-sentence-per-line.md'
         },
         fixable: 'whitespace',
         schema: [],
@@ -608,7 +319,7 @@ const rule$3 = {
             granularity: 'sentence'
         });
         return {
-            'root > paragraph > text': function(node) {
+            'paragraph > text': function(node) {
                 const range = sourceCode.getRange(node);
                 const originalText = sourceCode.getText(node);
                 const matches = [];
@@ -1108,10 +819,9 @@ var index = {
     },
     /// keep-sorted
     rules: {
-        'i18n-flat-key': rule$7,
-        'jsonc-inline-spacing': rule$6,
-        'jsx-attribute-spacing': rule$5,
-        'md-consistent-table-width': rule$4,
+        'i18n-flat-key': rule$6,
+        'jsonc-inline-spacing': rule$5,
+        'jsx-attribute-spacing': rule$4,
         'md-one-sentence-per-line': rule$3,
         'no-dependency-version-prefix': rule$2,
         'prefer-early-return': rule$1,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-hyoban",
   "type": "module",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "Hyoban extended ESLint rules.",
   "author": {
     "name": "hyoban",
@@ -28,9 +28,6 @@
   "peerDependencies": {
     "eslint": "*"
   },
-  "dependencies": {
-    "fast-string-width": "^3.0.2"
-  },
   "devDependencies": {
     "@eslint/markdown": "^7.5.1",
     "@types/mdast": "^4.0.4",