eslint-plugin-no-indexed-access-prop 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Valeri Vatchev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,267 @@
+# eslint-plugin-no-indexed-access-prop
+
+ESLint- and Oxlint-compatible rule for forbidding TypeScript indexed access types such as `User['id']` or `T[K]`.
+
+The package exports one rule:
+
+- `no-indexed-access-prop`
+
+## What it flags
+
+Examples reported by default:
+
+```ts
+type UserId = User['id'];
+type Value<T, K extends keyof T> = T[K];
+type UserValue = User['id' | 'name'];
+```
+
+The rule can also be configured more narrowly:
+
+- block all indexed access types
+- block only literal property access such as `T['id']`
+- block only selected literal property names such as `['id', 'name']`
+
+## Suggestions
+
+The rule provides safe editor suggestions when the replacement can be derived from local syntax alone.
+
+Example:
+
+```ts
+type UserId = { id: string }['id'];
+```
+
+Suggested replacement:
+
+```ts
+type UserId = string;
+```
+
+Suggestions are intentionally not emitted for cases that would require cross-file or type-aware resolution, such as:
+
+```ts
+type UserId = User['id'];
+type Value<T, K extends keyof T> = T[K];
+```
+
+## Installation
+
+### ESLint
+
+```bash
+npm install --save-dev eslint eslint-plugin-no-indexed-access-prop
+```
+
+### Oxlint
+
+```bash
+npm install --save-dev oxlint eslint-plugin-no-indexed-access-prop
+```
+
+## Usage
+
+### ESLint flat config
+
+```js
+import noIndexedAccessProp from 'eslint-plugin-no-indexed-access-prop';
+
+export default [
+  {
+    files: ['**/*.{ts,tsx}'],
+    plugins: {
+      noIndexedAccessProp,
+    },
+    rules: {
+      'noIndexedAccessProp/no-indexed-access-prop': 'error',
+    },
+  },
+];
+```
+
+### Oxlint
+
+Using an explicit alias keeps the rule name stable and short:
+
+```json
+{
+  "jsPlugins": [
+    {
+      "name": "no-indexed-access-prop",
+      "specifier": "eslint-plugin-no-indexed-access-prop"
+    }
+  ],
+  "rules": {
+    "no-indexed-access-prop/no-indexed-access-prop": "error"
+  }
+}
+```
+
+## Options
+
+The rule accepts a single options object.
+
+### `mode`
+
+Controls which indexed access forms are reported.
+
+- `"all"` (default): report every indexed access type
+- `"literal-only"`: report only string-literal access such as `T['id']` or `T['id' | 'name']`
+- `"configured-only"`: report only configured literal property names
+
+### `allowGenericIndex`
+
+Only meaningful in `mode: "all"`.
+
+When `true`, generic or non-literal indexed access such as `T[K]` is allowed, while literal property access is still reported.
+
+### `allowUnionLiteralIndex`
+
+When `true`, union-literal access such as `T['id' | 'name']` is allowed.
+
+This exemption applies in every mode.
+
+### `properties`
+
+Required when `mode: "configured-only"`.
+
+Specifies the blocked literal property names.
+
+## Configuration examples
+
+### Block everything
+
+```json
+{
+  "rules": {
+    "no-indexed-access-prop/no-indexed-access-prop": "error"
+  }
+}
+```
+
+### Block only literal property access
+
+```json
+{
+  "rules": {
+    "no-indexed-access-prop/no-indexed-access-prop": [
+      "error",
+      { "mode": "literal-only" }
+    ]
+  }
+}
+```
+
+### Block only selected properties
+
+```json
+{
+  "rules": {
+    "no-indexed-access-prop/no-indexed-access-prop": [
+      "error",
+      { "mode": "configured-only", "properties": ["id", "name"] }
+    ]
+  }
+}
+```
+
+### Allow `T[K]` but still block literal property access
+
+```json
+{
+  "rules": {
+    "no-indexed-access-prop/no-indexed-access-prop": [
+      "error",
+      { "mode": "all", "allowGenericIndex": true }
+    ]
+  }
+}
+```
+
+### Allow union-literal access
+
+```json
+{
+  "rules": {
+    "no-indexed-access-prop/no-indexed-access-prop": [
+      "error",
+      { "mode": "literal-only", "allowUnionLiteralIndex": true }
+    ]
+  }
+}
+```
+
+## Option migration
+
+Older examples may show this shape:
+
+```json
+{ "properties": ["id"] }
+```
+
+That shape has been replaced. Use:
+
+```json
+{ "mode": "configured-only", "properties": ["id"] }
+```
+
+## Development
+
+```bash
+npm install
+npm test
+```
+
+## Publishing notes
+
+Before publishing to npm, verify at least the following:
+
+1. `package.json` has the final package name and version
+2. any desired registry metadata such as `repository`, `bugs`, `homepage`, and `license` is set
+3. `npm test` passes
+4. `npm pack --dry-run` contains only the intended artifacts
+
+### First publish from a personal npm account
+
+npm trusted publishing cannot be the first publish for a brand new package. The package must already exist on npm before a trusted publisher can be attached to it.
+
+This repository includes scripts that isolate the bootstrap publish from your global npm login by using a repo-local user config file, `.npmrc.publish`, via npm's `--userconfig` support.
+
+Bootstrap flow:
+
+```bash
+npm run publish:login
+npm run publish:whoami
+npm test
+npm run publish:bootstrap:dry-run
+npm run publish:bootstrap
+```
+
+What this does:
+
+- `publish:login` logs into the public npm registry using `./.npmrc.publish` instead of your global `~/.npmrc`
+- `publish:whoami` confirms the active npm identity from that local config
+- `publish:bootstrap` performs the one-time initial publish from your personal account
+
+The `.npmrc.publish` file is gitignored and can be deleted after the first publish if you do not want to keep the local credentials around.
+
+### Trusted publishing with GitHub Actions
+
+After the first publish succeeds, configure npm trusted publishing for future releases:
+
+1. Open the package settings on npmjs.com
+2. Open the `Trusted Publisher` section
+3. Choose `GitHub Actions`
+4. Configure:
+   - Organization or user: `ValTM`
+   - Repository: `eslint-plugin-no-indexed-access-prop`
+   - Workflow filename: `publish.yml`
+
+After that, future releases can be published from GitHub Actions without a long-lived npm token.
+
+Trusted publishing references:
+
+- https://docs.npmjs.com/trusted-publishers
+- https://docs.npmjs.com/generating-provenance-statements
+- https://docs.npmjs.com/cli/v11/commands/npm-trust
+- https://docs.github.com/en/actions/tutorials/publish-packages/publish-nodejs-packages

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { RULE_NAME, noIndexedAccessPropRule } from "./rules/no-indexed-access-prop.js";
+export declare const PACKAGE_NAME = "eslint-plugin-no-indexed-access-prop";
+export declare const PACKAGE_VERSION = "0.1.0";
+export declare const rules: {
+    readonly "no-indexed-access-prop": import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceWithInlinePropertyType" | "replaceWithInlinePropertyTypeUnion" | "unexpectedIndexedAccess" | "unexpectedPropertyIndexedAccess", [import("./rules/no-indexed-access-prop.js").NoIndexedAccessPropOptions], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+};
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        readonly "no-indexed-access-prop": import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceWithInlinePropertyType" | "replaceWithInlinePropertyTypeUnion" | "unexpectedIndexedAccess" | "unexpectedPropertyIndexedAccess", [import("./rules/no-indexed-access-prop.js").NoIndexedAccessPropOptions], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    };
+};
+export { RULE_NAME, noIndexedAccessPropRule };
+export default plugin;

package/dist/index.js

@@ -0,0 +1,15 @@
+import { RULE_NAME, noIndexedAccessPropRule } from "./rules/no-indexed-access-prop.js";
+export const PACKAGE_NAME = "eslint-plugin-no-indexed-access-prop";
+export const PACKAGE_VERSION = "0.1.0";
+export const rules = {
+    [RULE_NAME]: noIndexedAccessPropRule,
+};
+const plugin = {
+    meta: {
+        name: PACKAGE_NAME,
+        version: PACKAGE_VERSION,
+    },
+    rules,
+};
+export { RULE_NAME, noIndexedAccessPropRule };
+export default plugin;

package/dist/rules/no-indexed-access-prop.d.ts

@@ -0,0 +1,18 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const RULE_NAME = "no-indexed-access-prop";
+export type NoIndexedAccessPropOptions = {
+    readonly mode?: "all";
+    readonly allowGenericIndex?: boolean;
+    readonly allowUnionLiteralIndex?: boolean;
+} | {
+    readonly mode: "literal-only";
+    readonly allowUnionLiteralIndex?: boolean;
+} | {
+    readonly mode: "configured-only";
+    readonly properties: readonly string[];
+    readonly allowUnionLiteralIndex?: boolean;
+};
+type Options = [NoIndexedAccessPropOptions];
+type MessageIds = "replaceWithInlinePropertyType" | "replaceWithInlinePropertyTypeUnion" | "unexpectedIndexedAccess" | "unexpectedPropertyIndexedAccess";
+export declare const noIndexedAccessPropRule: ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener>;
+export {};

package/dist/rules/no-indexed-access-prop.js

@@ -0,0 +1,220 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export const RULE_NAME = "no-indexed-access-prop";
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+function getMode(options) {
+    return options.mode ?? "all";
+}
+function getConfiguredProperties(options) {
+    if (options.mode !== "configured-only") {
+        return null;
+    }
+    return new Set(options.properties);
+}
+function getStringLiteralPropertyName(indexType) {
+    if (indexType.type !== "TSLiteralType") {
+        return null;
+    }
+    const literal = indexType.literal;
+    if (literal.type === "Literal" && typeof literal.value === "string") {
+        return literal.value;
+    }
+    return null;
+}
+function getLiteralIndexAccess(indexType) {
+    const propertyName = getStringLiteralPropertyName(indexType);
+    if (propertyName != null) {
+        return {
+            kind: "single-literal",
+            propertyNames: [propertyName],
+        };
+    }
+    if (indexType.type !== "TSUnionType") {
+        return null;
+    }
+    const propertyNames = [];
+    for (const member of indexType.types) {
+        const memberPropertyName = getStringLiteralPropertyName(member);
+        if (memberPropertyName == null) {
+            return null;
+        }
+        propertyNames.push(memberPropertyName);
+    }
+    return {
+        kind: "union-literal",
+        propertyNames: [...new Set(propertyNames)],
+    };
+}
+function getPropertySignatureName(member) {
+    if (member.computed || member.optional) {
+        return null;
+    }
+    if (member.key.type === "Identifier") {
+        return member.key.name;
+    }
+    if (member.key.type === "Literal" && typeof member.key.value === "string") {
+        return member.key.value;
+    }
+    return null;
+}
+function getInlinePropertyTypeText(objectType, propertyName, sourceCode) {
+    for (const member of objectType.members) {
+        if (member.type !== "TSPropertySignature") {
+            continue;
+        }
+        if (getPropertySignatureName(member) !== propertyName) {
+            continue;
+        }
+        if (member.typeAnnotation == null) {
+            return null;
+        }
+        return sourceCode.getText(member.typeAnnotation.typeAnnotation);
+    }
+    return null;
+}
+function getSuggestion(node, sourceCode) {
+    const objectType = node.objectType;
+    const literalIndexAccess = getLiteralIndexAccess(node.indexType);
+    if (objectType.type !== "TSTypeLiteral" || literalIndexAccess == null) {
+        return null;
+    }
+    const propertyTypeTexts = [];
+    for (const propertyName of literalIndexAccess.propertyNames) {
+        const propertyTypeText = getInlinePropertyTypeText(objectType, propertyName, sourceCode);
+        if (propertyTypeText == null) {
+            return null;
+        }
+        propertyTypeTexts.push(propertyTypeText);
+    }
+    if (propertyTypeTexts.length === 1) {
+        return {
+            messageId: "replaceWithInlinePropertyType",
+            replacementText: propertyTypeTexts[0],
+        };
+    }
+    return {
+        messageId: "replaceWithInlinePropertyTypeUnion",
+        replacementText: propertyTypeTexts.map((propertyTypeText) => `(${propertyTypeText})`).join(" | "),
+    };
+}
+function getReportDescriptor(options, configuredProperties, literalIndexAccess) {
+    if (literalIndexAccess?.kind === "union-literal" && options.allowUnionLiteralIndex) {
+        return null;
+    }
+    switch (getMode(options)) {
+        case "literal-only":
+            if (literalIndexAccess == null) {
+                return null;
+            }
+            return {
+                messageId: "unexpectedIndexedAccess",
+            };
+        case "configured-only": {
+            if (literalIndexAccess == null || configuredProperties == null) {
+                return null;
+            }
+            const matchedProperties = literalIndexAccess.propertyNames.filter((property) => configuredProperties.has(property));
+            if (matchedProperties.length === 0) {
+                return null;
+            }
+            return {
+                messageId: "unexpectedPropertyIndexedAccess",
+                data: {
+                    properties: matchedProperties.map((property) => `'${property}'`).join(", "),
+                },
+            };
+        }
+        case "all":
+            if (literalIndexAccess == null && "allowGenericIndex" in options && options.allowGenericIndex) {
+                return null;
+            }
+            return {
+                messageId: "unexpectedIndexedAccess",
+            };
+    }
+    return null;
+}
+export const noIndexedAccessPropRule = createRule({
+    name: RULE_NAME,
+    meta: {
+        type: "problem",
+        hasSuggestions: true,
+        docs: {
+            description: "Disallow TypeScript indexed access types using an explicit enforcement mode and optional exemptions.",
+        },
+        schema: [
+            {
+                oneOf: [
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            mode: { type: "string", enum: ["all"] },
+                            allowGenericIndex: { type: "boolean" },
+                            allowUnionLiteralIndex: { type: "boolean" },
+                        },
+                    },
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            mode: { type: "string", enum: ["literal-only"] },
+                            allowUnionLiteralIndex: { type: "boolean" },
+                        },
+                        required: ["mode"],
+                    },
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            mode: { type: "string", enum: ["configured-only"] },
+                            properties: {
+                                type: "array",
+                                items: {
+                                    type: "string",
+                                },
+                                minItems: 1,
+                                uniqueItems: true,
+                            },
+                            allowUnionLiteralIndex: { type: "boolean" },
+                        },
+                        required: ["mode", "properties"],
+                    },
+                ],
+            },
+        ],
+        messages: {
+            replaceWithInlinePropertyType: "Replace this indexed access with the inline property type.",
+            replaceWithInlinePropertyTypeUnion: "Replace this indexed access with the corresponding inline property type union.",
+            unexpectedIndexedAccess: "Do not use TypeScript indexed access types. Prefer a named alias or a direct property declaration.",
+            unexpectedPropertyIndexedAccess: "Do not use TypeScript indexed access types for blocked properties: {{ properties }}.",
+        },
+    },
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const configuredProperties = getConfiguredProperties(options);
+        return {
+            TSIndexedAccessType(node) {
+                const literalIndexAccess = getLiteralIndexAccess(node.indexType);
+                const suggestion = getSuggestion(node, context.sourceCode);
+                const reportDescriptor = getReportDescriptor(options, configuredProperties, literalIndexAccess);
+                if (reportDescriptor == null) {
+                    return;
+                }
+                context.report({
+                    node,
+                    ...reportDescriptor,
+                    suggest: suggestion == null
+                        ? undefined
+                        : [
+                            {
+                                messageId: suggestion.messageId,
+                                fix(fixer) {
+                                    return fixer.replaceText(node, suggestion.replacementText);
+                                },
+                            },
+                        ],
+                });
+            },
+        };
+    },
+});

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "eslint-plugin-no-indexed-access-prop",
+  "version": "0.1.0",
+  "description": "ESLint and Oxlint plugin that forbids TypeScript indexed access property types.",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "oxlint",
+    "typescript",
+    "indexed-access",
+    "typescript-eslint"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ValTM/eslint-plugin-no-indexed-access-prop.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ValTM/eslint-plugin-no-indexed-access-prop/issues"
+  },
+  "homepage": "https://github.com/ValTM/eslint-plugin-no-indexed-access-prop#readme",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./rules/no-indexed-access-prop": {
+      "types": "./dist/rules/no-indexed-access-prop.d.ts",
+      "import": "./dist/rules/no-indexed-access-prop.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build",
+    "publish:login": "npm login --registry https://registry.npmjs.org --userconfig ./.npmrc.publish",
+    "publish:whoami": "npm --registry https://registry.npmjs.org --userconfig ./.npmrc.publish whoami",
+    "publish:bootstrap:dry-run": "npm --registry https://registry.npmjs.org --userconfig ./.npmrc.publish publish --dry-run",
+    "publish:bootstrap": "npm --registry https://registry.npmjs.org --userconfig ./.npmrc.publish publish",
+    "test:unit": "node --test tests/no-indexed-access-prop.test.mjs",
+    "test:oxlint": "node --test tests/oxlint-smoke.test.mjs",
+    "test": "npm run build && npm run test:unit && npm run test:oxlint"
+  },
+  "peerDependencies": {
+    "eslint": ">=9"
+  },
+  "devDependencies": {
+    "@typescript-eslint/parser": "^8.58.2",
+    "@typescript-eslint/rule-tester": "^8.58.2",
+    "@typescript-eslint/utils": "^8.58.2",
+    "eslint": "^10.2.0",
+    "oxlint": "^1.60.0",
+    "typescript": "^6.0.2"
+  }
+}