@tai-kun/vp-lint-plugins 0.0.0-stage → 0.0.1

package/dist/src/rules/object-sort-utils.js

@@ -0,0 +1,221 @@
+function getLineStarts(text) {
+    const starts = [0];
+    for (let index = 0; index < text.length; index += 1) {
+        if (text[index] === "\n") {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function getLineIndent(text, lineStarts, line) {
+    const start = lineStarts[line - 1] ?? 0;
+    const match = /^[ \t]*/u.exec(text.slice(start));
+    return match?.[0] ?? "";
+}
+function getPropertyName(property) {
+    if (property.type !== "Property" || property.computed || property.kind !== "init") {
+        return null;
+    }
+    const key = property.key;
+    let name;
+    if (key.type === "Identifier") {
+        name = key.name;
+    }
+    else if (key.type === "Literal" &&
+        (typeof key.value === "string" || typeof key.value === "number")) {
+        name = String(key.value);
+    }
+    else {
+        return null;
+    }
+    return name === "__proto__" ? null : name;
+}
+function isSortableObject(node, allowRest) {
+    if (node.properties.length < 2) {
+        return false;
+    }
+    const names = new Set();
+    for (const [index, property] of node.properties.entries()) {
+        if (property.type === "RestElement") {
+            if (!allowRest || index !== node.properties.length - 1) {
+                return false;
+            }
+            continue;
+        }
+        const name = getPropertyName(property);
+        if (name === null || names.has(name)) {
+            return false;
+        }
+        names.add(name);
+    }
+    return true;
+}
+function compareNames(left, right) {
+    if (left.length !== right.length) {
+        return left.length - right.length;
+    }
+    const leftLower = left.toLowerCase();
+    const rightLower = right.toLowerCase();
+    if (leftLower !== rightLower) {
+        return leftLower < rightLower ? -1 : 1;
+    }
+    if (left === right) {
+        return 0;
+    }
+    return left < right ? -1 : 1;
+}
+function compareUnits(left, right) {
+    return compareNames(left.name, right.name);
+}
+function sortGroup(group) {
+    const sortable = group.filter((unit) => unit.name !== null);
+    sortable.sort(compareUnits);
+    const rest = group.filter((unit) => unit.name === null);
+    return [...sortable, ...rest];
+}
+/**
+ * オブジェクトリテラル／オブジェクトパターンの並び替え計画を返します。
+ *
+ * - プロパティー名の長さが短い順、同じ長さなら名前順
+ * - 空行で区切られたグループ内だけで並び替え
+ * - プロパティー直上のコメントはプロパティーと一緒に移動
+ *
+ * 並び替えが安全でない場合は null を返します。
+ */
+function getSortPlan(node, sourceCode, options = {}) {
+    const { allowRest = false, forceMultiline = true } = options;
+    if (!isSortableObject(node, allowRest)) {
+        return null;
+    }
+    const source = sourceCode.text;
+    const lineStarts = getLineStarts(source);
+    const lineIndent = getLineIndent(source, lineStarts, node.loc.start.line);
+    const comments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1]);
+    const firstProperty = node.properties[0];
+    if (firstProperty === undefined) {
+        return null;
+    }
+    const inlineStart = firstProperty.loc.start.line === node.loc.start.line;
+    const singleLine = node.loc.start.line === node.loc.end.line;
+    const units = [];
+    if (inlineStart) {
+        if (comments.length > 0) {
+            return null;
+        }
+        for (const property of node.properties) {
+            const isRest = property.type === "RestElement";
+            units.push({
+                name: isRest ? null : getPropertyName(property),
+                text: source.slice(property.range[0], property.range[1]),
+                endLine: property.loc.end.line,
+                property,
+                startLine: property.loc.start.line,
+            });
+        }
+    }
+    else {
+        let previousProperty = null;
+        for (const property of node.properties) {
+            const previous = previousProperty;
+            const boundary = previous === null ? node.range[0] + 1 : previous.range[1];
+            const candidates = comments.filter((comment) => comment.range[0] >= boundary && comment.range[1] <= property.range[0]);
+            if (previous !== null &&
+                comments.some((comment) => comment.loc.start.line === previous.loc.end.line &&
+                    comment.range[0] >= previous.range[1] &&
+                    comment.range[1] <= property.range[0])) {
+                return null;
+            }
+            const attached = [];
+            let expectedLine = property.loc.start.line;
+            for (let index = candidates.length - 1; index >= 0; index -= 1) {
+                const comment = candidates[index];
+                if (comment === undefined) {
+                    continue;
+                }
+                if (comment.loc.end.line !== expectedLine && comment.loc.end.line !== expectedLine - 1) {
+                    return null;
+                }
+                if (comment.loc.start.line === expectedLine) {
+                    return null;
+                }
+                if (comment.loc.start.line === node.loc.start.line) {
+                    return null;
+                }
+                attached.unshift(comment);
+                expectedLine = comment.loc.start.line;
+            }
+            if (attached.length !== candidates.length) {
+                return null;
+            }
+            const first = attached[0] ?? property;
+            const startLine = first.loc.start.line;
+            const unitStart = lineStarts[startLine - 1] ?? 0;
+            const isRest = property.type === "RestElement";
+            units.push({
+                name: isRest ? null : getPropertyName(property),
+                text: source.slice(unitStart, property.range[1]),
+                endLine: property.loc.end.line,
+                property,
+                startLine,
+            });
+            previousProperty = property;
+        }
+        const lastProperty = node.properties.at(-1);
+        if (lastProperty === undefined) {
+            return null;
+        }
+        if (comments.some((comment) => comment.range[0] >= lastProperty.range[1] && comment.range[1] <= node.range[1] - 1)) {
+            return null;
+        }
+    }
+    const groups = [];
+    let currentGroup = [];
+    let previousEndLine = null;
+    for (const unit of units) {
+        if (previousEndLine !== null && unit.startLine > previousEndLine + 1) {
+            groups.push(currentGroup);
+            currentGroup = [];
+        }
+        currentGroup.push(unit);
+        previousEndLine = unit.endLine;
+    }
+    if (currentGroup.length > 0) {
+        groups.push(currentGroup);
+    }
+    let needsSort = false;
+    for (const group of groups) {
+        const sorted = sortGroup(group);
+        if (sorted.some((unit, index) => unit !== group[index])) {
+            needsSort = true;
+            break;
+        }
+    }
+    const needsFormat = forceMultiline && inlineStart;
+    if (!needsSort && !needsFormat) {
+        return {
+            needsFix: false,
+            replacement: null,
+        };
+    }
+    if (singleLine && !forceMultiline) {
+        const sortedUnits = sortGroup(units);
+        return {
+            needsFix: true,
+            replacement: `{ ${sortedUnits.map((unit) => unit.text).join(", ")} }`,
+        };
+    }
+    const groupsText = groups
+        .map((group) => sortGroup(group)
+        .map((unit) => unit.text)
+        .join(",\n"))
+        .join(",\n\n");
+    const lastUnit = groups.flatMap((group) => sortGroup(group)).at(-1);
+    const trailingComma = lastUnit?.property.type === "RestElement" ? "" : ",";
+    return {
+        needsFix: true,
+        replacement: `{\n${groupsText}${trailingComma}\n${lineIndent}}`,
+    };
+}
+export { getSortPlan, compareNames };

package/dist/src/rules/overload-signatures-adjacent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * オーバーロード署名と実装の間に空行を入れないようにします。
+ */
+declare const overloadSignaturesAdjacent: import("vite-plus/lint/plugins").Rule;
+export default overloadSignaturesAdjacent;
+//# sourceMappingURL=overload-signatures-adjacent.d.ts.map

package/dist/src/rules/overload-signatures-adjacent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overload-signatures-adjacent.d.ts","sourceRoot":"","sources":["../../../src/rules/overload-signatures-adjacent.ts"],"names":[],"mappings":"AAiGA;;GAEG;AACH,QAAA,MAAM,0BAA0B,uCAqG9B,CAAC;eAEY,0BAA0B"}

package/dist/src/rules/overload-signatures-adjacent.js

@@ -0,0 +1,143 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { getNextStatement } from "./blank-line.js";
+function getFunction(node) {
+    if (node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction") {
+        return node;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration !== null) {
+        const declaration = node.declaration;
+        if (declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") {
+            return declaration;
+        }
+    }
+    return null;
+}
+function getKeyName(node) {
+    if (node.computed) {
+        return null;
+    }
+    const key = node.key;
+    if (key.type === "Identifier") {
+        return key.name;
+    }
+    if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) {
+        return String(key.value);
+    }
+    return null;
+}
+function getRemoveBlankLinesFix(fixer, sourceCode, previous, next) {
+    if (next.loc.start.line <= previous.loc.end.line + 1) {
+        return null;
+    }
+    const fromLineEnd = sourceCode.text.indexOf("\n", previous.range[1]);
+    if (fromLineEnd === -1) {
+        return null;
+    }
+    const nextLineStart = sourceCode.text.lastIndexOf("\n", next.range[0]) + 1;
+    const indent = sourceCode.text.slice(nextLineStart, next.range[0]);
+    if (indent.trim() !== "") {
+        return null;
+    }
+    return fixer.replaceTextRange([fromLineEnd, next.range[0]], `\n${indent}`);
+}
+function hasCommentBetween(sourceCode, previous, next) {
+    return sourceCode
+        .getAllComments()
+        .some((comment) => comment.range[0] >= previous.range[1] && comment.range[1] <= next.range[0]);
+}
+function reportIfSeparated(context, sourceCode, previous, next) {
+    if (next.loc.start.line <= previous.loc.end.line + 1 ||
+        hasCommentBetween(sourceCode, previous, next)) {
+        return;
+    }
+    context.report({
+        fix(fixer) {
+            return getRemoveBlankLinesFix(fixer, sourceCode, previous, next);
+        },
+        node: next,
+        messageId: "adjacent",
+    });
+}
+/**
+ * オーバーロード署名と実装の間に空行を入れないようにします。
+ */
+const overloadSignaturesAdjacent = defineRule({
+    meta: {
+        docs: {
+            description: "Require overload signatures and their implementation to be adjacent.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            adjacent: "Overload signatures must be adjacent to each other and to the implementation.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            ClassBody(node) {
+                for (let index = 1; index < node.body.length; index += 1) {
+                    const previous = node.body[index - 1];
+                    const next = node.body[index];
+                    if (previous === undefined ||
+                        next === undefined ||
+                        previous.type !== "MethodDefinition" ||
+                        previous.value.body !== null ||
+                        next.type !== "MethodDefinition") {
+                        continue;
+                    }
+                    const previousName = getKeyName(previous);
+                    const nextName = getKeyName(next);
+                    if (previousName === null || previousName !== nextName) {
+                        continue;
+                    }
+                    reportIfSeparated(context, sourceCode, previous, next);
+                }
+            },
+            TSDeclareFunction(node) {
+                if (node.body !== null) {
+                    return;
+                }
+                const nextStatement = getNextStatement(node);
+                if (nextStatement === null) {
+                    return;
+                }
+                const nextFunction = getFunction(nextStatement);
+                if (nextFunction === null || nextFunction.id?.name !== node.id?.name) {
+                    return;
+                }
+                reportIfSeparated(context, sourceCode, node, nextStatement);
+            },
+            FunctionDeclaration(node) {
+                if (node.body !== null) {
+                    return;
+                }
+                const nextStatement = getNextStatement(node);
+                if (nextStatement === null) {
+                    return;
+                }
+                const nextFunction = getFunction(nextStatement);
+                if (nextFunction === null || nextFunction.id?.name !== node.id?.name) {
+                    return;
+                }
+                reportIfSeparated(context, sourceCode, node, nextStatement);
+            },
+            ExportNamedDeclaration(node) {
+                const currentFunction = getFunction(node);
+                if (currentFunction === null || currentFunction.body !== null) {
+                    return;
+                }
+                const nextStatement = getNextStatement(node);
+                if (nextStatement === null) {
+                    return;
+                }
+                const nextFunction = getFunction(nextStatement);
+                if (nextFunction === null || nextFunction.id?.name !== currentFunction.id?.name) {
+                    return;
+                }
+                reportIfSeparated(context, sourceCode, node, nextStatement);
+            },
+        };
+    },
+});
+export default overloadSignaturesAdjacent;

package/dist/src/rules/sort-import-export-specifiers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * import / export の波括弧内の specifier を並べます。
+ *
+ * 「型 → 変数など → default」のグループ順で、各グループ内は名前の長さが短い順、同じ長さなら名前順です。
+ */
+declare const sortImportExportSpecifiers: import("vite-plus/lint/plugins").Rule;
+export default sortImportExportSpecifiers;
+//# sourceMappingURL=sort-import-export-specifiers.d.ts.map

package/dist/src/rules/sort-import-export-specifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-import-export-specifiers.d.ts","sourceRoot":"","sources":["../../../src/rules/sort-import-export-specifiers.ts"],"names":[],"mappings":"AAwEA;;;;GAIG;AACH,QAAA,MAAM,0BAA0B,uCAkH9B,CAAC;eAEY,0BAA0B"}

package/dist/src/rules/sort-import-export-specifiers.js

@@ -0,0 +1,130 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { compareNames } from "./object-sort-utils.js";
+function getSpecifierName(node) {
+    if (node.type === "Identifier") {
+        return node.name;
+    }
+    if (node.type === "Literal") {
+        return node.value;
+    }
+    return null;
+}
+function getLineIndent(source, offset) {
+    const lineStart = source.lastIndexOf("\n", offset) + 1;
+    const match = /^[ \t]*/u.exec(source.slice(lineStart, offset));
+    return match?.[0] ?? "";
+}
+function hasUnsafeComment(node, specifiers, sourceCode) {
+    const comments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1]);
+    return comments.some((comment) => !specifiers.some((specifier) => comment.range[0] >= specifier.range[0] && comment.range[1] <= specifier.range[1]));
+}
+function buildReplacement(units, sourceCode, first, last) {
+    const sorted = [...units].sort((left, right) => {
+        if (left.group !== right.group) {
+            return left.group - right.group;
+        }
+        return compareNames(left.name, right.name);
+    });
+    if (sorted.every((unit, index) => unit === units[index])) {
+        return null;
+    }
+    const multiline = first.loc.start.line !== last.loc.end.line;
+    const separator = multiline ? `,\n${getLineIndent(sourceCode.text, first.range[0])}` : ", ";
+    return sorted.map((unit) => unit.text).join(separator);
+}
+/**
+ * import / export の波括弧内の specifier を並べます。
+ *
+ * 「型 → 変数など → default」のグループ順で、各グループ内は名前の長さが短い順、同じ長さなら名前順です。
+ */
+const sortImportExportSpecifiers = defineRule({
+    meta: {
+        docs: {
+            description: "Sort import and export specifiers by group (type, value, default), then by name length and name.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            sort: "Import/export specifiers must be sorted by group, name length, then name.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        function reportSort(node, specifiers, units) {
+            const first = specifiers[0];
+            const last = specifiers.at(-1);
+            if (first === undefined || last === undefined) {
+                return;
+            }
+            const replacement = buildReplacement(units, sourceCode, first, last);
+            if (replacement === null) {
+                return;
+            }
+            context.report({
+                fix(fixer) {
+                    return fixer.replaceTextRange([first.range[0], last.range[1]], replacement);
+                },
+                node,
+                messageId: "sort",
+            });
+        }
+        return {
+            ImportDeclaration(node) {
+                const specifiers = node.specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
+                if (specifiers.length < 2 || hasUnsafeComment(node, specifiers, sourceCode)) {
+                    return;
+                }
+                const units = [];
+                for (const specifier of specifiers) {
+                    const name = getSpecifierName(specifier.imported);
+                    if (name === null) {
+                        return;
+                    }
+                    let group = 1;
+                    if (node.importKind === "type" || specifier.importKind === "type") {
+                        group = 0;
+                    }
+                    else if (name === "default") {
+                        group = 2;
+                    }
+                    units.push({
+                        name,
+                        text: sourceCode.text.slice(specifier.range[0], specifier.range[1]),
+                        group,
+                    });
+                }
+                reportSort(node, specifiers, units);
+            },
+            ExportNamedDeclaration(node) {
+                const { specifiers } = node;
+                if (specifiers.length < 2 || hasUnsafeComment(node, specifiers, sourceCode)) {
+                    return;
+                }
+                const units = [];
+                for (const specifier of specifiers) {
+                    const localName = getSpecifierName(specifier.local);
+                    const exportedName = getSpecifierName(specifier.exported);
+                    if (localName === null || exportedName === null) {
+                        return;
+                    }
+                    let group = 1;
+                    if (node.exportKind === "type" || specifier.exportKind === "type") {
+                        group = 0;
+                    }
+                    else if (localName === "default" || exportedName === "default") {
+                        group = 2;
+                    }
+                    units.push({
+                        name: localName,
+                        text: sourceCode.text.slice(specifier.range[0], specifier.range[1]),
+                        group,
+                    });
+                }
+                reportSort(node, specifiers, units);
+            },
+        };
+    },
+});
+export default sortImportExportSpecifiers;

package/dist/src/rules/sort-jsx-props.d.ts

@@ -0,0 +1,7 @@
+/**
+ * JSX の props を「一般 → on* → aria-* → data-*」のグループ順に並べます。
+ * 各グループ内ではプロパティー名の長さが短い順、同じ長さなら名前順です。
+ */
+declare const sortJsxProps: import("vite-plus/lint/plugins").Rule;
+export default sortJsxProps;
+//# sourceMappingURL=sort-jsx-props.d.ts.map

package/dist/src/rules/sort-jsx-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-jsx-props.d.ts","sourceRoot":"","sources":["../../../src/rules/sort-jsx-props.ts"],"names":[],"mappings":"AAsEA;;;GAGG;AACH,QAAA,MAAM,YAAY,uCAwEhB,CAAC;eAEY,YAAY"}

package/dist/src/rules/sort-jsx-props.js

@@ -0,0 +1,102 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { compareNames } from "./object-sort-utils.js";
+function isNamedAttribute(attribute) {
+    return attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier";
+}
+function getAttributeGroup(name) {
+    if (/^on[A-Z].*/u.test(name)) {
+        return 1;
+    }
+    if (/^aria-.+/u.test(name)) {
+        return 2;
+    }
+    if (/^data-.+/u.test(name)) {
+        return 3;
+    }
+    return 0;
+}
+function compareAttributes(left, right) {
+    const leftGroup = getAttributeGroup(left.name);
+    const rightGroup = getAttributeGroup(right.name);
+    if (leftGroup !== rightGroup) {
+        return leftGroup - rightGroup;
+    }
+    return compareNames(left.name, right.name);
+}
+function getLineIndent(source, offset) {
+    const lineStart = source.lastIndexOf("\n", offset) + 1;
+    const match = /^[ \t]*/u.exec(source.slice(lineStart, offset));
+    return match?.[0] ?? "";
+}
+function hasCommentBetweenAttributes(attributes, sourceCode) {
+    const comments = sourceCode.getAllComments();
+    return attributes.some((attribute, index) => {
+        const nextAttribute = attributes[index + 1];
+        if (nextAttribute === undefined) {
+            return false;
+        }
+        return comments.some((comment) => comment.range[0] >= attribute.range[1] && comment.range[1] <= nextAttribute.range[0]);
+    });
+}
+/**
+ * JSX の props を「一般 → on* → aria-* → data-*」のグループ順に並べます。
+ * 各グループ内ではプロパティー名の長さが短い順、同じ長さなら名前順です。
+ */
+const sortJsxProps = defineRule({
+    meta: {
+        docs: {
+            description: "Sort JSX props by group (general, on*, aria-*, data-*), then by name length and name.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            sort: "JSX props must be sorted by group, name length, then name.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            JSXOpeningElement(node) {
+                const attributes = node.attributes.filter(isNamedAttribute);
+                if (attributes.length < 2 || attributes.length !== node.attributes.length) {
+                    return;
+                }
+                const names = new Set();
+                for (const attribute of attributes) {
+                    if (names.has(attribute.name.name)) {
+                        return;
+                    }
+                    names.add(attribute.name.name);
+                }
+                if (hasCommentBetweenAttributes(attributes, sourceCode)) {
+                    return;
+                }
+                const units = attributes.map((attribute) => ({
+                    name: attribute.name.name,
+                    text: sourceCode.text.slice(attribute.range[0], attribute.range[1]),
+                }));
+                const sorted = [...units].sort(compareAttributes);
+                if (sorted.every((unit, index) => unit === units[index])) {
+                    return;
+                }
+                const firstAttribute = attributes[0];
+                const lastAttribute = attributes.at(-1);
+                if (firstAttribute === undefined || lastAttribute === undefined) {
+                    return;
+                }
+                const multiline = firstAttribute.loc.start.line !== lastAttribute.loc.end.line;
+                const separator = multiline
+                    ? `\n${getLineIndent(sourceCode.text, firstAttribute.range[0])}`
+                    : " ";
+                context.report({
+                    fix(fixer) {
+                        return fixer.replaceTextRange([firstAttribute.range[0], lastAttribute.range[1]], sorted.map((unit) => unit.text).join(separator));
+                    },
+                    node,
+                    messageId: "sort",
+                });
+            },
+        };
+    },
+});
+export default sortJsxProps;

package/dist/src/rules/sort-object-properties.d.ts

@@ -0,0 +1,9 @@
+/**
+ * オブジェクトリテラルのプロパティーを、名前の長さが短い順、同じ長さなら名前順に並べます。
+ *
+ * 空行で区切られたグループは意図的なまとまりとみなし、グループ内だけで並べ替えます。
+ * プロパティー直上のコメントはプロパティーと一緒に移動します。
+ */
+declare const sortObjectProperties: import("vite-plus/lint/plugins").Rule;
+export default sortObjectProperties;
+//# sourceMappingURL=sort-object-properties.d.ts.map

package/dist/src/rules/sort-object-properties.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-object-properties.d.ts","sourceRoot":"","sources":["../../../src/rules/sort-object-properties.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB,uCAiDxB,CAAC;eAEY,oBAAoB"}