@mrpalmer/eslint-plugin 1.0.0

package/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const pluginName = "mrpalmer";
+export type PluginName = typeof pluginName;

package/lib/constants.js

@@ -0,0 +1 @@
+export const pluginName = 'mrpalmer';

package/lib/index.d.ts

@@ -0,0 +1,36 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const _default: {
+    configs: {
+        recommended: {
+            name: string;
+            plugins: {
+                mrpalmer: {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        'shorten-paths': TSESLint.RuleModule<"shortenImport" | "shortenExport", import("./rules/shorten-paths.js").Options, unknown, TSESLint.RuleListener>;
+                        'sort-imports': TSESLint.RuleModule<"error" | "order" | "noLineBetweenImports", [import("./rules/sort-imports.js").Options], unknown, TSESLint.RuleListener>;
+                        'sort-named': TSESLint.RuleModule<"order", [import("./rules/sort-named.js").Options], unknown, TSESLint.RuleListener>;
+                    };
+                };
+            };
+            rules: {
+                'mrpalmer/shorten-paths': "warn";
+                'mrpalmer/sort-imports': "warn";
+                'mrpalmer/sort-named': "warn";
+            };
+        };
+    };
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'shorten-paths': TSESLint.RuleModule<"shortenImport" | "shortenExport", import("./rules/shorten-paths.js").Options, unknown, TSESLint.RuleListener>;
+        'sort-imports': TSESLint.RuleModule<"error" | "order" | "noLineBetweenImports", [import("./rules/sort-imports.js").Options], unknown, TSESLint.RuleListener>;
+        'sort-named': TSESLint.RuleModule<"order", [import("./rules/sort-named.js").Options], unknown, TSESLint.RuleListener>;
+    };
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,31 @@
+import { meta } from './meta.js';
+// rules
+import shortenPathsRule from './rules/shorten-paths.js';
+import sortImportsRule from './rules/sort-imports.js';
+import sortNamedRule from './rules/sort-named.js';
+const rules = {
+    'shorten-paths': shortenPathsRule,
+    'sort-imports': sortImportsRule,
+    'sort-named': sortNamedRule,
+};
+const plugin = {
+    meta,
+    rules,
+};
+const recommended = {
+    name: 'mrpalmer/recommended',
+    plugins: {
+        mrpalmer: plugin,
+    },
+    rules: {
+        'mrpalmer/shorten-paths': 'warn',
+        'mrpalmer/sort-imports': 'warn',
+        'mrpalmer/sort-named': 'warn',
+    },
+};
+export default {
+    ...plugin,
+    configs: {
+        recommended,
+    },
+};

package/lib/meta.d.ts

@@ -0,0 +1,4 @@
+export declare const meta: {
+    name: string;
+    version: string;
+};

package/lib/meta.js

@@ -0,0 +1,17 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { name, version } = getMeta(require('../package.json'));
+export const meta = { name, version };
+function getMeta(pkgJson) {
+    if (typeof pkgJson !== 'object' || pkgJson === null) {
+        throw new TypeError('Expected an object');
+    }
+    if (!('name' in pkgJson) || !('version' in pkgJson)) {
+        throw new TypeError('Expected name and version properties in package.json');
+    }
+    const { name, version } = pkgJson;
+    if (typeof name !== 'string' || typeof version !== 'string') {
+        throw new TypeError('Expected name and version properties to be strings');
+    }
+    return { name, version };
+}

package/lib/rules/shorten-paths.d.ts

@@ -0,0 +1,8 @@
+type MessageIds = 'shortenImport' | 'shortenExport';
+export type Options = [
+    {
+        breakTies: 'alias' | 'relative';
+    }
+];
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;

package/lib/rules/shorten-paths.js

@@ -0,0 +1,70 @@
+import path from 'node:path';
+import { createRule } from '../utils/create-rule.js';
+import { loadConfig } from '../utils/ts-config.js';
+import { getImportPathOptions } from '../utils/import-path-options.js';
+import { getShortestPath } from '../utils/shortest-path.js';
+export default createRule({
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensure the shortest available path is used for imports and exports.',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    breakTies: {
+                        type: 'string',
+                        enum: ['alias', 'relative'],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            shortenImport: 'Import can be shortened to "{{path}}"',
+            shortenExport: 'Export can be shortened to "{{path}}"',
+        },
+    },
+    defaultOptions: [
+        {
+            breakTies: 'alias',
+        },
+    ],
+    create(context, options) {
+        const config = loadConfig(context.settings);
+        const absolutePath = path.resolve(process.cwd(), context.filename);
+        return {
+            'ImportDeclaration,ExportNamedDeclaration,ExportAllDeclaration'(node) {
+                if (!node.source) {
+                    return;
+                }
+                const originalPath = node.source.value;
+                const pathOptions = getImportPathOptions({
+                    originalPath,
+                    filePath: absolutePath,
+                    tsconfig: config,
+                });
+                const shortest = getShortestPath(pathOptions, options);
+                if (originalPath === shortest) {
+                    return;
+                }
+                context.report({
+                    node: node.source,
+                    messageId: 
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+                    node.type === 'ImportDeclaration'
+                        ? 'shortenImport'
+                        : 'shortenExport',
+                    data: {
+                        path: shortest,
+                    },
+                    fix(fixer) {
+                        return fixer.replaceText(node.source, `'${shortest}'`);
+                    },
+                });
+            },
+        };
+    },
+});

package/lib/rules/sort-imports.d.ts

@@ -0,0 +1,19 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+import { type MinimatchOptions } from 'minimatch';
+import type { Arrayable } from '../types.js';
+import { type ImportType as ImportType_ } from '../utils/import-type.js';
+type ImportType = ImportType_ | 'core';
+interface PathGroup {
+    pattern: string;
+    group: ImportType;
+    patternOptions?: MinimatchOptions;
+    position?: 'before' | 'after';
+    isSideEffect?: boolean;
+}
+export interface Options {
+    groups: ReadonlyArray<Arrayable<ImportType>>;
+    pathGroups: PathGroup[];
+}
+type MessageId = 'error' | 'order' | 'noLineBetweenImports';
+declare const _default: TSESLint.RuleModule<MessageId, [Options], unknown, TSESLint.RuleListener>;
+export default _default;