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

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"}

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

@@ -0,0 +1,54 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { getSortPlan } from "./object-sort-utils.js";
+/**
+ * オブジェクトリテラルのプロパティーを、名前の長さが短い順、同じ長さなら名前順に並べます。
+ *
+ * 空行で区切られたグループは意図的なまとまりとみなし、グループ内だけで並べ替えます。
+ * プロパティー直上のコメントはプロパティーと一緒に移動します。
+ */
+const sortObjectProperties = defineRule({
+    meta: {
+        docs: {
+            description: "Sort object properties by name length and name, preserving comment groups separated by blank lines.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            sort: "Object properties must be sorted by name length, then by name.",
+        },
+    },
+    create(context) {
+        return {
+            ObjectPattern(node) {
+                const plan = getSortPlan(node, context.sourceCode, {
+                    allowRest: true,
+                    forceMultiline: false,
+                });
+                if (plan === null || !plan.needsFix) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        return fixer.replaceText(node, plan.replacement);
+                    },
+                    node,
+                    messageId: "sort",
+                });
+            },
+            ObjectExpression(node) {
+                const plan = getSortPlan(node, context.sourceCode);
+                if (plan === null || !plan.needsFix) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        return fixer.replaceText(node, plan.replacement);
+                    },
+                    node,
+                    messageId: "sort",
+                });
+            },
+        };
+    },
+});
+export default sortObjectProperties;

package/dist/src/rules/sort-type-members.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 型リテラルのメンバーを、名前の長さが短い順、同じ長さなら名前順に並べます。
+ *
+ * `interface` は対象外です。
+ */
+declare const sortTypeMembers: import("vite-plus/lint/plugins").Rule;
+export default sortTypeMembers;
+//# sourceMappingURL=sort-type-members.d.ts.map

package/dist/src/rules/sort-type-members.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-type-members.d.ts","sourceRoot":"","sources":["../../../src/rules/sort-type-members.ts"],"names":[],"mappings":"AAuPA;;;;GAIG;AACH,QAAA,MAAM,eAAe,uCA4CnB,CAAC;eAEY,eAAe"}

package/dist/src/rules/sort-type-members.js

@@ -0,0 +1,213 @@
+import { defineRule } from "vite-plus/lint/plugins";
+import { compareNames } from "./object-sort-utils.js";
+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 getMemberName(member) {
+    if (member.type !== "TSPropertySignature" && member.type !== "TSMethodSignature") {
+        return null;
+    }
+    if (member.computed) {
+        return null;
+    }
+    const key = member.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 getUnits(node, sourceCode) {
+    const source = sourceCode.text;
+    const lineStarts = getLineStarts(source);
+    const comments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.range[0] >= node.range[0] && comment.range[1] <= node.range[1]);
+    const units = [];
+    let previousEnd = node.range[0] + 1;
+    for (const [index, member] of node.members.entries()) {
+        const previousMember = node.members[index - 1];
+        const candidates = comments.filter((comment) => comment.range[0] >= previousEnd && comment.range[1] <= member.range[0]);
+        if (previousMember !== undefined &&
+            candidates.some((comment) => comment.loc.start.line === previousMember.loc.end.line)) {
+            return null;
+        }
+        const attached = [];
+        let expectedLine = member.loc.start.line;
+        for (let commentIndex = candidates.length - 1; commentIndex >= 0; commentIndex -= 1) {
+            const comment = candidates[commentIndex];
+            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] ?? member;
+        const startLine = first.loc.start.line;
+        let startOffset;
+        if (attached.length > 0) {
+            startOffset = lineStarts[startLine - 1] ?? first.range[0];
+        }
+        else if (startLine === node.loc.start.line) {
+            startOffset = member.range[0];
+        }
+        else {
+            startOffset = lineStarts[startLine - 1] ?? member.range[0];
+        }
+        let endOffset = member.range[1];
+        while (endOffset > member.range[0]) {
+            const character = source[endOffset - 1];
+            if (character !== ";" && character !== ",") {
+                break;
+            }
+            endOffset -= 1;
+        }
+        units.push({
+            name: getMemberName(member),
+            text: source.slice(startOffset, endOffset),
+            endLine: member.loc.end.line,
+            endOffset,
+            startLine,
+            startOffset,
+        });
+        previousEnd = member.range[1];
+    }
+    if (comments.some((comment) => comment.range[0] >= previousEnd && comment.range[1] <= node.range[1] - 1)) {
+        return null;
+    }
+    return units;
+}
+function splitGroups(units) {
+    const groups = [];
+    let current = [];
+    let previousEndLine = null;
+    for (const unit of units) {
+        if (previousEndLine !== null && unit.startLine > previousEndLine + 1) {
+            groups.push(current);
+            current = [];
+        }
+        current.push(unit);
+        previousEndLine = unit.endLine;
+    }
+    if (current.length > 0) {
+        groups.push(current);
+    }
+    return groups;
+}
+function sortGroup(group) {
+    const sortable = group.filter((unit) => unit.name !== null);
+    sortable.sort((left, right) => compareNames(left.name, right.name));
+    const rest = group.filter((unit) => unit.name === null);
+    return [...sortable, ...rest];
+}
+function getSortEdits(units) {
+    const edits = [];
+    let runStart = 0;
+    while (runStart < units.length) {
+        if (units[runStart]?.name === null) {
+            runStart += 1;
+            continue;
+        }
+        let runEnd = runStart;
+        while (runEnd < units.length && units[runEnd]?.name !== null) {
+            runEnd += 1;
+        }
+        const run = units.slice(runStart, runEnd);
+        if (run.length >= 2) {
+            const names = new Set();
+            let hasDuplicate = false;
+            for (const unit of run) {
+                if (unit.name === null) {
+                    continue;
+                }
+                if (names.has(unit.name)) {
+                    hasDuplicate = true;
+                    break;
+                }
+                names.add(unit.name);
+            }
+            if (!hasDuplicate) {
+                const groups = splitGroups(run);
+                const sortedGroups = groups.map(sortGroup);
+                const changed = sortedGroups.some((group, groupIndex) => group.some((unit, unitIndex) => unit !== groups[groupIndex]?.[unitIndex]));
+                const firstUnit = run[0];
+                const lastUnit = run.at(-1);
+                if (changed && firstUnit !== undefined && lastUnit !== undefined) {
+                    edits.push({
+                        end: lastUnit.endOffset,
+                        text: sortedGroups
+                            .map((group) => group.map((unit) => unit.text).join(";\n"))
+                            .join(";\n\n"),
+                        start: firstUnit.startOffset,
+                    });
+                }
+            }
+        }
+        runStart = runEnd;
+    }
+    return edits;
+}
+/**
+ * 型リテラルのメンバーを、名前の長さが短い順、同じ長さなら名前順に並べます。
+ *
+ * `interface` は対象外です。
+ */
+const sortTypeMembers = defineRule({
+    meta: {
+        docs: {
+            description: "Sort type literal members by name length and name.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            sort: "Type members must be sorted by name length, then by name.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            TSTypeLiteral(node) {
+                const units = getUnits(node, sourceCode);
+                if (units === null) {
+                    return;
+                }
+                const edits = getSortEdits(units);
+                if (edits.length === 0) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        const fixes = [];
+                        for (const edit of edits) {
+                            fixes.push(fixer.replaceTextRange([edit.start, edit.end], edit.text));
+                        }
+                        return fixes;
+                    },
+                    node,
+                    messageId: "sort",
+                });
+            },
+        };
+    },
+});
+export default sortTypeMembers;

package/dist/src/rules/spaced-comment.d.ts

@@ -0,0 +1,6 @@
+/**
+ * コメントの開始記号の直後と終了記号の直前に空白を要求します。
+ */
+declare const spacedComment: import("vite-plus/lint/plugins").Rule;
+export default spacedComment;
+//# sourceMappingURL=spaced-comment.d.ts.map

package/dist/src/rules/spaced-comment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaced-comment.d.ts","sourceRoot":"","sources":["../../../src/rules/spaced-comment.ts"],"names":[],"mappings":"AAyBA;;GAEG;AACH,QAAA,MAAM,aAAa,uCAkGjB,CAAC;eAEY,aAAa"}

package/dist/src/rules/spaced-comment.js

@@ -0,0 +1,105 @@
+import { defineRule } from "vite-plus/lint/plugins";
+const DECORATIVE_LINE = /^[-=*#_~+]{3,}$/u;
+function isWhitespace(char) {
+    return char === " " || char === "\t";
+}
+function isExemptLineComment(raw) {
+    if (raw.startsWith("///") || raw.startsWith("//!") || raw.startsWith("//@")) {
+        return true;
+    }
+    if (raw.startsWith("//#")) {
+        return true;
+    }
+    return DECORATIVE_LINE.test(raw.slice(2));
+}
+function isExemptBlockComment(raw) {
+    return raw.startsWith("/*!");
+}
+/**
+ * コメントの開始記号の直後と終了記号の直前に空白を要求します。
+ */
+const spacedComment = defineRule({
+    meta: {
+        docs: {
+            description: "Require whitespace after the comment marker and before the closing marker.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            missingLeadingSpace: "Expected a whitespace after the comment marker.",
+            missingTrailingSpace: "Expected a whitespace before the closing comment marker.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        function checkLineComment(comment, raw) {
+            if (isExemptLineComment(raw) || isWhitespace(raw[2]) || raw.length === 2) {
+                return;
+            }
+            context.report({
+                fix(fixer) {
+                    return fixer.insertTextAfterRange([comment.range[0], comment.range[0] + 2], " ");
+                },
+                loc: comment.loc,
+                messageId: "missingLeadingSpace",
+            });
+        }
+        function checkBlockComment(comment, raw) {
+            if (isExemptBlockComment(raw)) {
+                return;
+            }
+            const prefixLength = raw.startsWith("/**") ? 3 : 2;
+            const firstLineEnd = raw.indexOf("\n");
+            const lastLineStart = raw.lastIndexOf("\n") + 1;
+            let needsLeading;
+            let needsTrailing;
+            if (firstLineEnd === -1) {
+                const contentStart = prefixLength;
+                const contentEnd = raw.lastIndexOf("*/");
+                const content = raw.slice(contentStart, contentEnd);
+                needsLeading = content !== "" && !isWhitespace(content[0]);
+                needsTrailing = content !== "" && !isWhitespace(content.at(-1));
+            }
+            else {
+                const firstLine = raw.slice(0, firstLineEnd);
+                const lastLine = raw.slice(lastLineStart);
+                const leadingContent = firstLine.slice(prefixLength);
+                const closeIndex = lastLine.lastIndexOf("*/");
+                const trailingContent = lastLine.slice(0, closeIndex);
+                needsLeading = leadingContent !== "" && !isWhitespace(leadingContent[0]);
+                needsTrailing = trailingContent !== "" && !isWhitespace(trailingContent.at(-1));
+            }
+            if (!needsLeading && !needsTrailing) {
+                return;
+            }
+            context.report({
+                fix(fixer) {
+                    const fixes = [];
+                    if (needsLeading) {
+                        fixes.push(fixer.insertTextAfterRange([comment.range[0], comment.range[0] + prefixLength], " "));
+                    }
+                    if (needsTrailing) {
+                        fixes.push(fixer.insertTextBeforeRange([comment.range[1] - 2, comment.range[1]], " "));
+                    }
+                    return fixes;
+                },
+                loc: comment.loc,
+                messageId: needsLeading ? "missingLeadingSpace" : "missingTrailingSpace",
+            });
+        }
+        return {
+            Program() {
+                for (const comment of sourceCode.getAllComments()) {
+                    if (comment.type === "Line") {
+                        checkLineComment(comment, sourceCode.getText(comment));
+                        continue;
+                    }
+                    if (comment.type === "Block") {
+                        checkBlockComment(comment, sourceCode.getText(comment));
+                    }
+                }
+            },
+        };
+    },
+});
+export default spacedComment;

package/dist/src/rules/type-literal-properties-newline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * メンバーが 2 つ以上ある型リテラルを複数行にします。
+ *
+ * Oxfmt の `objectWrap` はオブジェクトリテラル用のため、型リテラルは `{` の直後の改行を目印に複数行を維持します。
+ */
+declare const typeLiteralPropertiesNewline: import("vite-plus/lint/plugins").Rule;
+export default typeLiteralPropertiesNewline;
+//# sourceMappingURL=type-literal-properties-newline.d.ts.map

package/dist/src/rules/type-literal-properties-newline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-literal-properties-newline.d.ts","sourceRoot":"","sources":["../../../src/rules/type-literal-properties-newline.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,QAAA,MAAM,4BAA4B,uCAkChC,CAAC;eAEY,4BAA4B"}

package/dist/src/rules/type-literal-properties-newline.js

@@ -0,0 +1,39 @@
+import { defineRule } from "vite-plus/lint/plugins";
+/**
+ * メンバーが 2 つ以上ある型リテラルを複数行にします。
+ *
+ * Oxfmt の `objectWrap` はオブジェクトリテラル用のため、型リテラルは `{` の直後の改行を目印に複数行を維持します。
+ */
+const typeLiteralPropertiesNewline = defineRule({
+    meta: {
+        docs: {
+            description: "Enforce multiline type literals when they have two or more members.",
+        },
+        type: "layout",
+        fixable: "whitespace",
+        messages: {
+            multiline: "Type literals with 2 or more members must be multiline.",
+        },
+    },
+    create(context) {
+        return {
+            TSTypeLiteral(node) {
+                if (node.members.length < 2) {
+                    return;
+                }
+                const firstMember = node.members[0];
+                if (firstMember === undefined || firstMember.loc.start.line !== node.loc.start.line) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        return fixer.insertTextAfterRange([node.range[0], node.range[0] + 1], "\n");
+                    },
+                    node,
+                    messageId: "multiline",
+                });
+            },
+        };
+    },
+});
+export default typeLiteralPropertiesNewline;

package/package.json

@@ -1,10 +1,42 @@
 {
   "name": "@tai-kun/vp-lint-plugins",
-  "version": "0.0.0",
-  "description": "OIDC trusted publishing setup package for @tai-kun/vp-lint-plugins",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "version": "0.0.1",
+  "description": "",
+  "homepage": "https://tai-kun.github.io/vp-lint-plugins/",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/tai-kun/vp-lint-plugins",
+    "directory": "packages/vp-lint-plugins"
+  },
+  "files": [
+    "dist",
+    "src",
+    "package.json",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "devDependencies": {
+    "@tsconfig/node24": "24.0.5",
+    "@tsconfig/strictest": "2.0.8",
+    "@types/node": "24.19.2",
+    "@vitest/coverage-v8": "5.0.5",
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.3.0",
+    "vite-plus": "1.3.0",
+    "vitest": "5.0.5"
+  },
+  "peerDependencies": {
+    "vite-plus": "^1.0.0"
+  },
+  "readme": "README.md",
+  "scripts": {
+    "build": "tsc --project ./.config/tsconfig.build.json"
+  }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+export { default as blankLineAfterControlBlock } from "./rules/blank-line-after-control-block.js";
+export { default as blankLineAfterDeclaration } from "./rules/blank-line-after-declaration.js";
+export { default as blankLineAfterVariableDeclaration } from "./rules/blank-line-after-variable-declaration.js";
+export { default as blankLineBeforeReturn } from "./rules/blank-line-before-return.js";
+export { default as blankLineBetweenClassMembers } from "./rules/blank-line-between-class-members.js";
+export { default as blankLineBetweenSwitchCases } from "./rules/blank-line-between-switch-cases.js";
+export { default as commentJapaneseSpacing } from "./rules/comment-japanese-spacing.js";
+export { default as commentOneSentencePerLine } from "./rules/comment-one-sentence-per-line.js";
+export { default as jsdocParamOrder } from "./rules/jsdoc-param-order.js";
+export { default as jsdocTagLines } from "./rules/jsdoc-tag-lines.js";
+export { default as jsdocTagOrder } from "./rules/jsdoc-tag-order.js";
+export { default as memberOrdering } from "./rules/member-ordering.js";
+export { default as objectPropertiesNewline } from "./rules/object-properties-newline.js";
+export { default as overloadSignaturesAdjacent } from "./rules/overload-signatures-adjacent.js";
+export { default as sortImportExportSpecifiers } from "./rules/sort-import-export-specifiers.js";
+export { default as sortJsxProps } from "./rules/sort-jsx-props.js";
+export { default as sortObjectProperties } from "./rules/sort-object-properties.js";
+export { default as sortTypeMembers } from "./rules/sort-type-members.js";
+export { default as spacedComment } from "./rules/spaced-comment.js";
+export { default as typeLiteralPropertiesNewline } from "./rules/type-literal-properties-newline.js";
+
+export { default } from "./plugin.js";