eslint-plugin-flawless 0.1.0

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright for portions of eslint-plugin-arrow-return-style-x are held by u3u,
+2023 as part of eslint-plugin-arrow-return-style. All other copyright for
+eslint-plugin-arrow-return-style-x are held by Christopher Buss
+<christopher.buss@pm.me>, 2025.
+
+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,200 @@
+# eslint-plugin-template
+
+> A modern, TypeScript-first template for building ESLint plugins (Flat Config
+> ready)
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+
+This repository is a starter template for creating your own ESLint plugin with:
+
+- ESLint 9 Flat Config support out of the box
+- TypeScript with strong typing for rules and options
+- Vitest-based rule tests via eslint-vitest-rule-tester
+- Rule scaffolding script to generate rule code, tests, and docs
+- Auto-generated README rules section via eslint-doc-generator
+
+Use it as a “Use this template” on GitHub or fork and rename.
+
+## Quick start
+
+1. Create your repo from this template
+
+- Click “Use this template” on GitHub, or
+- Degit locally: `degit christopher-buss/eslint-plugin-template my-plugin`
+
+2. Install dependencies
+
+```pwsh
+pnpm i
+```
+
+3. Rename the package and plugin
+
+Update these fields to your plugin name (e.g., `eslint-plugin-awesome`):
+
+- `package.json` → `name`, `description`, `repository`, `author`, `license`
+- README title and badges
+
+The runtime plugin name (used in config) is derived from the package name by
+removing the `eslint-plugin-` prefix. For `eslint-plugin-awesome` the plugin key
+becomes `awesome`.
+
+4. Scaffold your first rule
+
+```pwsh
+pnpm create-rule my-new-rule
+```
+
+This generates:
+
+- `src/rules/my-new-rule/rule.ts` – rule implementation
+- `src/rules/my-new-rule/rule.spec.ts` – tests
+- `src/rules/my-new-rule/documentation.md` – rule docs
+
+5. Run tests and docs
+
+```pwsh
+pnpm test
+pnpm eslint-docs
+```
+
+The docs command updates the auto-generated rules list in this README.
+
+## Using your plugin
+
+Once published to npm as `eslint-plugin-awesome`, you can enable it in a
+project.
+
+### Flat Config (ESLint 9+)
+
+```js
+// eslint.config.js / eslint.config.mjs / eslint.config.ts
+import yourPlugin from "eslint-plugin-awesome";
+
+export default [
+	// Enable all recommended rules from your plugin
+	yourPlugin.configs.recommended,
+
+	// Or wire it manually
+	{
+		plugins: {
+			awesome: yourPlugin,
+		},
+		rules: {
+			"awesome/my-new-rule": "error",
+		},
+	},
+];
+```
+
+### Legacy Config (.eslintrc)
+
+```json
+{
+	"extends": ["plugin:yourname/recommended"]
+}
+```
+
+## Development
+
+Scripts you’ll use during development:
+
+- `pnpm dev` – fast stub build for local iteration
+- `pnpm build` – type-safe build with d.ts via tsdown
+- `pnpm test` – run Vitest tests
+- `pnpm lint` – run ESLint on this repo
+- `pnpm typecheck` – run `tsc --noEmit`
+- `pnpm eslint-docs` – regenerate README rules list
+- `pnpm release` – bump version via bumpp
+
+Requirements:
+
+- Node.js >= 20
+- pnpm >= 10
+- ESLint >= 9.15.0 (peer dep for consumers)
+
+## Project structure
+
+```text
+src/
+	configs/            # Flat config presets (e.g., recommended)
+	rules/              # Your rules (each in its own folder)
+	plugin.ts           # Plugin host (name, version, rules)
+	util.ts             # Rule creator with docs links
+	index.ts            # Entry combining plugin + configs (default export)
+scripts/
+	create-rule.ts      # Scaffolds a new rule (code, tests, docs)
+	template/           # Rule templates used by the script
+```
+
+{ "extends": ["plugin:awesome/recommended"] }
+
+- The plugin key is computed from your package name (see `src/plugin.ts`).
+- `src/configs/recommended` is provided for convenience; add your rules there
+  when ready.
+
+## Scaffolding a rule
+
+```pwsh
+pnpm create-rule my-new-rule
+```
+
+What happens:
+
+1. Creates `src/rules/my-new-rule/` with `rule.ts`, `rule.spec.ts`,
+   `documentation.md`.
+2. Attempts to register the rule. If automatic edit cannot be applied, the
+   script prints the exact import and entry you can paste into your plugin/index
+   file.
+3. Run `pnpm test` to validate, then `pnpm eslint-docs` to refresh this README.
+
+## Publishing
+
+Typical flow:
+
+```pwsh
+pnpm test
+pnpm build
+pnpm release   # chooses the next semver and commits tags
+# CI publishes to npm
+```
+
+## Rules reference
+
+Generate this section with:
+
+```pwsh
+pnpm eslint-docs
+```
+
+<!-- begin auto-generated rules list -->
+
+💭 Requires
+[type information](https://typescript-eslint.io/linting/typed-linting).
+
+| Name                                                              | Description                                                 | 💭  |
+| :---------------------------------------------------------------- | :---------------------------------------------------------- | :-- |
+| [naming-convention](src/rules/naming-convention/documentation.md) | Enforce naming conventions for everything across a codebase | 💭  |
+
+<!-- end auto-generated rules list -->
+
+## Contributing
+
+PRs and issues welcome. If you’re using this as a template, adapt the sections
+to your needs and replace the badges and links.
+
+## License
+
+[MIT](./LICENSE) © 2025 [Christopher Buss](https://github.com/christopher-buss)
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/eslint-plugin-flawless
+[npm-version-href]: https://npmjs.com/package/eslint-plugin-flawless
+[npm-downloads-src]: https://img.shields.io/npm/dm/eslint-plugin-flawless
+[npm-downloads-href]: https://npmjs.com/package/eslint-plugin-flawless
+[license-src]:
+	https://img.shields.io/github/license/christopher-buss/eslint-plugin-template.svg
+[license-href]: ./LICENSE

package/dist/index.d.mts

@@ -0,0 +1,164 @@
+import { TSESLint } from "@typescript-eslint/utils";
+import "@typescript-eslint/utils/eslint-utils";
+import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import { Linter } from "eslint";
+
+//#region src/util.d.ts
+interface PluginDocumentation {
+  description: string;
+  recommended?: boolean;
+  requiresTypeChecking: boolean;
+}
+//#endregion
+//#region src/rules/naming-convention/utils/enums.d.ts
+declare const Selector: {
+  readonly variable: 1;
+  readonly function: 2;
+  readonly parameter: 4;
+  readonly objectStyleEnum: 8;
+  readonly parameterProperty: 16;
+  readonly classicAccessor: 32;
+  readonly enumMember: 64;
+  readonly classMethod: 128;
+  readonly objectLiteralMethod: 256;
+  readonly typeMethod: 512;
+  readonly classProperty: 1024;
+  readonly objectLiteralProperty: 2048;
+  readonly typeProperty: 4096;
+  readonly autoAccessor: 8192;
+  readonly class: 16384;
+  readonly interface: 32768;
+  readonly typeAlias: 65536;
+  readonly enum: 131072;
+  readonly typeParameter: 262144;
+  readonly import: 524288;
+};
+type SelectorString = keyof typeof Selector;
+declare const MetaSelector: {
+  readonly default: -1;
+  readonly variableLike: 15;
+  readonly memberLike: 16368;
+  readonly typeLike: 507904;
+  readonly method: 896;
+  readonly property: 7168;
+  readonly accessor: 8224;
+};
+type MetaSelectorString = keyof typeof MetaSelector;
+declare const Modifier: {
+  readonly const: 1;
+  readonly readonly: 2;
+  readonly static: 4;
+  readonly public: 8;
+  readonly protected: 16;
+  readonly private: 32;
+  readonly "#private": 64;
+  readonly abstract: 128;
+  readonly destructured: 256;
+  readonly global: 512;
+  readonly exported: 1024;
+  readonly unused: 2048;
+  readonly requiresQuotes: 4096;
+  readonly override: 8192;
+  readonly async: 16384;
+  readonly default: 32768;
+  readonly namespace: 65536;
+};
+type ModifierString = keyof typeof Modifier;
+declare const PredefinedFormat: {
+  readonly camelCase: 1;
+  readonly strictCamelCase: 2;
+  readonly PascalCase: 3;
+  readonly StrictPascalCase: 4;
+  readonly snake_case: 5;
+  readonly UPPER_CASE: 6;
+};
+type PredefinedFormatString = keyof typeof PredefinedFormat;
+declare const TypeModifier: {
+  readonly boolean: 131072;
+  readonly string: 262144;
+  readonly number: 524288;
+  readonly function: 1048576;
+  readonly array: 2097152;
+};
+type TypeModifierString = keyof typeof TypeModifier;
+declare const UnderscoreOption: {
+  readonly forbid: 1;
+  readonly allow: 2;
+  readonly require: 3;
+  readonly requireDouble: 4;
+  readonly allowDouble: 5;
+  readonly allowSingleOrDouble: 6;
+};
+type IndividualAndMetaSelectorsString = MetaSelectorString | SelectorString;
+type UnderscoreOptionString = keyof typeof UnderscoreOption;
+//#endregion
+//#region src/rules/naming-convention/utils/types.d.ts
+interface MatchRegex {
+  match: boolean;
+  regex: string;
+}
+interface NamingSelector {
+  custom?: MatchRegex;
+  filter?: MatchRegex | string;
+  /**
+   * Format options.
+   */
+  format: Array<PredefinedFormatString> | null;
+  leadingUnderscore?: UnderscoreOptionString;
+  modifiers?: Array<ModifierString>;
+  prefix?: Array<string>;
+  /**
+   * Selector options.
+   */
+  selector: Array<IndividualAndMetaSelectorsString> | IndividualAndMetaSelectorsString;
+  suffix?: Array<string>;
+  trailingUnderscore?: UnderscoreOptionString;
+  types?: Array<TypeModifierString>;
+}
+//#endregion
+//#region src/rules/naming-convention/rule.d.ts
+type MessageIds$1 = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
+type Options$1 = Array<NamingSelector>;
+//#endregion
+//#region src/plugin.d.ts
+declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    "naming-convention": TSESLint.RuleModule<MessageIds$1, Options$1, PluginDocumentation, TSESLint.RuleListener>;
+  };
+};
+//#endregion
+//#region src/index.d.ts
+declare const _default: {
+  configs: {
+    recommended: {
+      plugins: {
+        [x: string]: {
+          meta: {
+            name: string;
+            version: string;
+          };
+          rules: {
+            "naming-convention": _typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds$1, Options$1, PluginDocumentation, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+          };
+        };
+      };
+      rules: {};
+    };
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    "naming-convention": _typescript_eslint_utils_ts_eslint0.RuleModule<MessageIds$1, Options$1, PluginDocumentation, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+  };
+};
+type RuleOptions = { [K in keyof RuleDefinitions]: RuleDefinitions[K]["defaultOptions"] };
+type Rules = { [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]> };
+type RuleDefinitions = typeof plugin.rules;
+//#endregion
+export { RuleOptions, Rules, _default as default };