@pobammer-ts/eslint-cease-nonsense-rules 1.15.0 → 1.17.1

package/dist/rules/misleading-lua-tuple-checks.d.ts

@@ -0,0 +1,6 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+type MessageIds = "misleadingLuaTupleCheck" | "luaTupleDeclaration";
+declare const _default: TSESLint.RuleModule<MessageIds, [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/naming-convention.d.ts

@@ -0,0 +1,9 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+import type { Selector } from "../utilities/naming-convention-utilities";
+export type MessageIds = "doesNotMatchFormat" | "doesNotMatchFormatTrimmed" | "missingAffix" | "missingUnderscore" | "satisfyCustom" | "unexpectedUnderscore";
+export type NamingConventionOptions = Selector;
+export type Options = Array<NamingConventionOptions>;
+declare const _default: TSESLint.RuleModule<MessageIds, Options, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/no-unused-imports.d.ts

@@ -0,0 +1,9 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+export interface NoUnusedImportsOptions {
+    readonly checkJSDoc?: boolean;
+}
+type Options = [NoUnusedImportsOptions?];
+declare const _default: TSESLint.RuleModule<"unusedImport", Options, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/prefer-read-only-props.d.ts

@@ -0,0 +1,6 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+type MessageIds = "preferReadOnlyProps" | "readOnlyProp";
+declare const preferReadOnlyPropsRule: ESLintUtils.RuleModule<MessageIds, [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default preferReadOnlyPropsRule;

package/dist/rules/prevent-abbreviations.d.ts

@@ -0,0 +1,21 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+type MessageIds = "replace" | "suggestion";
+type ImportCheckOption = boolean | "internal";
+export interface PreventAbbreviationsOptions {
+    readonly checkProperties?: boolean;
+    readonly checkVariables?: boolean;
+    readonly checkDefaultAndNamespaceImports?: ImportCheckOption;
+    readonly checkShorthandImports?: ImportCheckOption;
+    readonly checkShorthandProperties?: boolean;
+    readonly checkFilenames?: boolean;
+    readonly extendDefaultReplacements?: boolean;
+    readonly replacements?: Record<string, Record<string, boolean> | false>;
+    readonly extendDefaultAllowList?: boolean;
+    readonly allowList?: Record<string, boolean>;
+    readonly ignore?: ReadonlyArray<string | RegExp>;
+}
+type Options = [PreventAbbreviationsOptions?];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/require-module-level-instantiation.d.ts

@@ -0,0 +1,25 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+import type { ReadonlyRecord } from "../types/utility-types";
+/**
+ * Configuration for classes that must be instantiated at module level.
+ *
+ * Maps class names to their expected import sources.
+ *
+ * @example
+ * ```typescript
+ * {
+ *   classes: {
+ *     "Log": "@rbxts/rbxts-sleitnick-log",
+ *     "Server": "@rbxts/net"
+ *   }
+ * }
+ * ```
+ */
+export interface RequireModuleLevelInstantiationOptions {
+    readonly classes: ReadonlyRecord<string, string>;
+}
+type Options = [RequireModuleLevelInstantiationOptions?];
+declare const _default: TSESLint.RuleModule<"mustBeModuleLevel", Options, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/use-exhaustive-dependencies.d.ts

@@ -1,4 +1,4 @@
-import type { Rule } from "eslint";
+import type { TSESLint } from "@typescript-eslint/utils";
 export interface HookEntry {
     readonly name: string;
     readonly closureIndex?: number;
@@ -10,5 +10,9 @@ export interface UseExhaustiveDependenciesOptions {
     readonly reportMissingDependenciesArray?: boolean;
     readonly reportUnnecessaryDependencies?: boolean;
 }
-declare const useExhaustiveDependencies: Rule.RuleModule;
+type MessageIds = "missingDependencies" | "missingDependenciesArray" | "missingDependency" | "unnecessaryDependency" | "unstableDependency" | "addDependenciesArraySuggestion" | "removeDependencySuggestion" | "addDependencySuggestion" | "addMissingDependenciesSuggestion";
+type Options = [UseExhaustiveDependenciesOptions?];
+declare const useExhaustiveDependencies: TSESLint.RuleModule<MessageIds, Options, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
 export default useExhaustiveDependencies;

package/dist/utilities/configure-utilities.d.ts

@@ -1,11 +1,15 @@
 import type { BanInstancesOptions } from "../rules/ban-instances";
 import type { ComplexityConfiguration } from "../rules/enforce-ianitor-check-type";
+import type { NamingConventionOptions } from "../rules/naming-convention";
 import type { NoGodComponentsOptions } from "../rules/no-god-components";
 import type { NoInstanceMethodsOptions } from "../rules/no-instance-methods-without-this";
 import type { NoMemoChildrenOptions } from "../rules/no-memo-children";
 import type { NoShorthandOptions } from "../rules/no-shorthand-names";
+import type { NoUnusedImportsOptions } from "../rules/no-unused-imports";
 import type { NoUselessUseSpringOptions } from "../rules/no-useless-use-spring";
 import type { PreferEnumItemOptions } from "../rules/prefer-enum-item";
+import type { PreventAbbreviationsOptions } from "../rules/prevent-abbreviations";
+import type { RequireModuleLevelInstantiationOptions } from "../rules/require-module-level-instantiation";
 import type { EffectFunctionOptions, HookConfiguration } from "../rules/require-named-effect-functions";
 import type { PairConfiguration, RequirePairedCallsOptions } from "../rules/require-paired-calls";
 import type { ReactKeysOptions } from "../rules/require-react-component-keys";
@@ -122,3 +126,27 @@ export declare function createPreferEnumItemOptions(options?: Partial<PreferEnum
  * @returns The full options
  */
 export declare function createRequireReactDisplayNamesOptions(options?: Partial<RequireReactDisplayNamesOptions>): RequireReactDisplayNamesOptions;
+/**
+ * Creates options for require-module-level-instantiation rule
+ * @param options - Partial configuration options
+ * @returns The full options
+ */
+export declare function createRequireModuleLevelInstantiationOptions(options?: Partial<RequireModuleLevelInstantiationOptions>): RequireModuleLevelInstantiationOptions;
+/**
+ * Creates options for naming-convention rule
+ * @param options - Partial configuration options
+ * @returns The full options
+ */
+export declare function createNamingConventionOptions(options?: Partial<NamingConventionOptions>): NamingConventionOptions;
+/**
+ * Creates options for no-unused-imports rule
+ * @param options - Partial configuration options
+ * @returns The full options
+ */
+export declare function createNoUnusedImportsOptions(options?: Partial<NoUnusedImportsOptions>): NoUnusedImportsOptions;
+/**
+ * Creates options for prevent-abbreviations rule
+ * @param options - Partial configuration options
+ * @returns The full options
+ */
+export declare function createPreventAbbreviationsOptions(options?: Partial<PreventAbbreviationsOptions>): PreventAbbreviationsOptions;

package/dist/utilities/naming-convention-utilities/enums.d.ts

@@ -0,0 +1,86 @@
+export declare const PredefinedFormats: {
+    camelCase: string;
+    PascalCase: string;
+    StrictPascalCase: string;
+    snake_case: string;
+    strictCamelCase: string;
+    UPPER_CASE: string;
+};
+export type PredefinedFormatsString = keyof typeof PredefinedFormats;
+export type PredefinedFormats = (typeof PredefinedFormats)[PredefinedFormatsString];
+export declare const UnderscoreOptions: {
+    allow: string;
+    allowDouble: string;
+    allowSingleOrDouble: string;
+    forbid: string;
+    require: string;
+    requireDouble: string;
+};
+export type UnderscoreOptionsString = keyof typeof UnderscoreOptions;
+export type UnderscoreOptions = (typeof UnderscoreOptions)[UnderscoreOptionsString];
+export declare const Selectors: {
+    autoAccessor: string;
+    class: string;
+    classicAccessor: string;
+    classMethod: string;
+    classProperty: string;
+    enum: string;
+    enumMember: string;
+    function: string;
+    import: string;
+    interface: string;
+    objectLiteralMethod: string;
+    objectLiteralProperty: string;
+    parameter: string;
+    parameterProperty: string;
+    typeAlias: string;
+    typeMethod: string;
+    typeParameter: string;
+    typeProperty: string;
+    variable: string;
+};
+export type SelectorsString = keyof typeof Selectors;
+export type Selectors = (typeof Selectors)[SelectorsString];
+export declare const MetaSelectors: {
+    accessor: string;
+    default: string;
+    memberLike: string;
+    method: string;
+    property: string;
+    typeLike: string;
+    variableLike: string;
+};
+export type MetaSelectorsString = keyof typeof MetaSelectors;
+export type IndividualAndMetaSelectorsString = MetaSelectorsString | SelectorsString;
+export declare const Modifiers: {
+    "#private": string;
+    abstract: string;
+    async: string;
+    const: string;
+    default: string;
+    destructured: string;
+    exported: string;
+    global: string;
+    namespace: string;
+    override: string;
+    private: string;
+    protected: string;
+    public: string;
+    readonly: string;
+    requiresQuotes: string;
+    static: string;
+    unused: string;
+};
+export type ModifiersString = keyof typeof Modifiers;
+export type Modifiers = (typeof Modifiers)[ModifiersString];
+export declare const TypeModifiers: {
+    array: string;
+    boolean: string;
+    function: string;
+    number: string;
+    string: string;
+};
+export type TypeModifiersString = keyof typeof TypeModifiers;
+export type TypeModifiers = (typeof TypeModifiers)[TypeModifiersString];
+export declare const ModifierWeights: Record<ModifiersString, number>;
+export declare const TypeModifierWeights: Record<TypeModifiersString, number>;

package/dist/utilities/naming-convention-utilities/format.d.ts

@@ -0,0 +1 @@
+export declare const PredefinedFormatToCheckFunction: Record<string, (name: string) => boolean>;

package/dist/utilities/naming-convention-utilities/get-enum-names.d.ts

@@ -0,0 +1 @@
+export declare function getEnumNames<EnumRecord extends Record<string, string>>(enumObject: EnumRecord): Array<keyof EnumRecord>;

package/dist/utilities/naming-convention-utilities/index.d.ts

@@ -0,0 +1,5 @@
+export { Modifiers } from "./enums";
+export { parseOptions } from "./parse-options";
+export { SCHEMA } from "./schema";
+export { selectorTypeToMessageString } from "./shared";
+export type { Context, Selector, ValidatorFunction } from "./types";

package/dist/utilities/naming-convention-utilities/parse-options.d.ts

@@ -0,0 +1,2 @@
+import type { Context, ParsedOptions } from "./types";
+export declare function parseOptions(context: Context): ParsedOptions;

package/dist/utilities/naming-convention-utilities/schema.d.ts

@@ -0,0 +1,2 @@
+import type { JSONSchema } from "@typescript-eslint/utils";
+export declare const SCHEMA: JSONSchema.JSONSchema4;

package/dist/utilities/naming-convention-utilities/shared.d.ts

@@ -0,0 +1,4 @@
+import type { IndividualAndMetaSelectorsString, MetaSelectorsString } from "./enums";
+export declare function selectorTypeToMessageString(selectorType: string): string;
+export declare function isMetaSelector(selector: IndividualAndMetaSelectorsString): selector is MetaSelectorsString;
+export declare function isMethodOrPropertySelector(selector: IndividualAndMetaSelectorsString): boolean;

package/dist/utilities/naming-convention-utilities/types.d.ts

@@ -0,0 +1,40 @@
+import type { TSESLint, TSESTree } from "@typescript-eslint/utils";
+import type { MessageIds, Options } from "../../rules/naming-convention";
+import type { IndividualAndMetaSelectorsString, ModifiersString, PredefinedFormatsString, TypeModifiersString, UnderscoreOptionsString } from "./enums";
+export interface MatchRegex {
+    match: boolean;
+    regex: string;
+}
+export interface Selector {
+    custom?: MatchRegex;
+    filter?: string | MatchRegex;
+    format?: Array<PredefinedFormatsString> | undefined;
+    leadingUnderscore?: UnderscoreOptionsString;
+    modifiers?: Array<ModifiersString>;
+    prefix?: Array<string>;
+    selector: IndividualAndMetaSelectorsString | Array<IndividualAndMetaSelectorsString>;
+    suffix?: Array<string>;
+    trailingUnderscore?: UnderscoreOptionsString;
+    types?: Array<TypeModifiersString>;
+}
+export interface NormalizedMatchRegex {
+    match: boolean;
+    regex: RegExp;
+}
+export interface NormalizedSelector {
+    custom?: NormalizedMatchRegex | undefined;
+    filter?: NormalizedMatchRegex | undefined;
+    format?: Array<PredefinedFormatsString> | undefined;
+    leadingUnderscore?: UnderscoreOptionsString | undefined;
+    modifiers?: Array<ModifiersString> | undefined;
+    modifierWeight: number;
+    prefix?: Array<string> | undefined;
+    selectors: Array<string>;
+    selectorPriority: number;
+    suffix?: Array<string> | undefined;
+    trailingUnderscore?: UnderscoreOptionsString | undefined;
+    types?: Array<TypeModifiersString> | undefined;
+}
+export type ValidatorFunction = (node: TSESTree.Identifier | TSESTree.Literal | TSESTree.PrivateIdentifier, modifiers?: Set<string>) => void;
+export type ParsedOptions = Record<string, ValidatorFunction>;
+export type Context = Readonly<TSESLint.RuleContext<MessageIds, Options>>;

package/dist/utilities/naming-convention-utilities/validator.d.ts

@@ -0,0 +1,3 @@
+import type { SelectorsString } from "./enums";
+import type { Context, NormalizedSelector, ValidatorFunction } from "./types";
+export declare function createValidator(type: SelectorsString, context: Context, allConfigs: Array<NormalizedSelector>): ValidatorFunction;

package/dist/utilities/pattern-replacement/pattern-types.d.ts

@@ -13,9 +13,7 @@ export interface Pattern<Match extends string = string> {
     readonly [PatternBrand]: Match;
     readonly match: Match;
     readonly replacement: string;
-    readonly when?: {
-        readonly [Key in ExtractCaptures<Match>]?: WhenCondition;
-    };
+    readonly when?: Readonly<Partial<Record<ExtractCaptures<Match>, WhenCondition>>>;
 }
 export declare function pattern<const Match extends string, const WhenClause extends object = object>(configuration: {
     readonly match: Match;

package/package.json

@@ -3,30 +3,38 @@
 	"dependencies": {
 		"arkregex": "^0.0.5",
 		"fast-diff": "^1.3.0",
-		"oxc-parser": "^0.107.0",
+		"oxc-parser": "^0.108.0",
 		"oxc-resolver": "^11.16.2",
 		"typebox": "^1.0.76"
 	},
 	"description": "A bunch of lints to prevent idiot mistakes I encounter with frequency.",
 	"devDependencies": {
+		"@babel/core": "^7.28.6",
+		"@babel/eslint-parser": "^7.28.6",
 		"@biomejs/biome": "^2.3.11",
+		"@commitlint/config-conventional": "^20.3.1",
+		"@commitlint/types": "^20.3.1",
 		"@jsr/cliffy__command": "^1.0.0-rc.8",
 		"@mitata/counters": "^0.0.8",
 		"@octokit/rest": "^22.0.1",
-		"@opencode-ai/plugin": "^1.1.10",
+		"@opencode-ai/plugin": "^1.1.18",
+		"@rbxts/types": "^1.0.896",
 		"@toon-format/toon": "^2.1.0",
 		"@total-typescript/ts-reset": "^0.6.1",
-		"@types/bun": "^1.3.5",
+		"@types/bun": "^1.3.6",
 		"@types/estree": "^1.0.8",
 		"@types/node": "^20.14.11",
-		"@typescript-eslint/parser": "^8.52.0",
-		"@typescript-eslint/scope-manager": "^8.52.0",
-		"@typescript-eslint/types": "^8.52.0",
-		"@typescript-eslint/utils": "^8.52.0",
-		"@typescript/native-preview": "7.0.0-dev.20260111.1",
+		"@typescript-eslint/parser": "^8.53.0",
+		"@typescript-eslint/rule-tester": "^8.53.0",
+		"@typescript-eslint/scope-manager": "^8.53.0",
+		"@typescript-eslint/types": "^8.53.0",
+		"@typescript-eslint/utils": "^8.53.0",
+		"@typescript/native-preview": "7.0.0-dev.20260113.1",
 		"arkenv": "^0.8.3",
 		"arktype": "^2.1.29",
-		"bumpp": "^10.3.2",
+		"better-result": "^2.1.0",
+		"bumpp": "^10.4.0",
+		"commitlint": "^20.3.1",
 		"confbox": "^0.2.2",
 		"consola": "^3.4.2",
 		"eslint": "9.39.2",
@@ -34,9 +42,9 @@
 		"knip": "^5.80.2",
 		"lint-staged": "^16.2.7",
 		"mitata": "^1.0.34",
-		"oxfmt": "^0.23.0",
-		"oxlint": "^1.38.0",
-		"oxlint-tsgolint": "^0.11.0",
+		"oxfmt": "^0.24.0",
+		"oxlint": "^1.39.0",
+		"oxlint-tsgolint": "^0.11.1",
 		"picocolors": "^1.1.1",
 		"pretty-bytes": "^7.1.0",
 		"pretty-ms": "^9.3.0",
@@ -45,8 +53,9 @@
 		"temporal-polyfill": "^0.3.0",
 		"ts-api-utils": "^2.4.0",
 		"ts-case-convert": "^2.1.0",
-		"type-fest": "^5.3.1",
-		"typescript": "^5.6.3"
+		"type-fest": "^5.4.0",
+		"typescript": "^5.6.3",
+		"vue-eslint-parser": "^10.2.0"
 	},
 	"engines": {
 		"bun": ">=1.1.0",
@@ -67,8 +76,8 @@
 	"name": "@pobammer-ts/eslint-cease-nonsense-rules",
 	"packageManager": "bun@1.3.5",
 	"peerDependencies": {
-		"@typescript-eslint/parser": "^8.52.0",
-		"@typescript-eslint/utils": "^8.52.0",
+		"@typescript-eslint/parser": "^8.53.0",
+		"@typescript-eslint/utils": "^8.53.0",
 		"eslint": "^9.39.2",
 		"oxfmt": ">0.19.0"
 	},
@@ -85,24 +94,30 @@
 		"url": "git+https://github.com/howmanysmall/eslint-cease-nonsense-rules.git"
 	},
 	"scripts": {
-		"biome:ci": "bun x --bun biome ci",
+		"add-tsgolint": "bun add -D oxlint-tsgolint@latest",
+		"biome:check": "biome check",
+		"biome:ci": "biome ci",
+		"biome:lint": "biome lint",
 		"build": "./scripts/build.ts",
-		"build:legacy": "bun x --bun tsgo -p tsconfig.json",
-		"dev": "bun x --bun tsgo -w",
-		"format": "bun x oxfmt",
-		"knip": "bun x --bun knip-bun",
-		"lint": "bun run oxc . && bun x --bun biome lint .",
-		"lint:fix": "bun run oxc . --fix && bun x --bun biome lint . --fix",
-		"oxc": "bun x oxlint --type-aware",
-		"prepare": "bun x --bun simple-git-hooks",
+		"build:legacy": "tsgo -p tsconfig.json",
+		"commitlint": "commitlint --edit",
+		"dev": "tsgo -w",
+		"format": "oxfmt",
+		"knip": "knip-bun",
+		"lint": "bun run oxc . && bun x --bun biome check src tests",
+		"lint:fix": "bun run oxc . --fix && bun x --bun biome check . --fix",
+		"oxc": "oxlint --type-aware",
+		"oxc:complete": "oxlint --type-aware --type-aware",
+		"oxc:raw": "oxlint",
+		"prepare": "simple-git-hooks",
 		"prepublishOnly": "bun run build",
 		"release": "bumpp",
-		"test": "bun test",
-		"type-check": "bun x --bun tsgo --noEmit",
-		"type-check:safe": "bun x --bun tsc --noEmit"
+		"test": "bun test --randomize",
+		"type-check": "tsgo --noEmit",
+		"type-check:safe": "tsc --noEmit"
 	},
 	"sideEffects": false,
 	"type": "module",
 	"types": "./dist/index.d.ts",
-	"version": "1.15.0"
+	"version": "1.17.1"
 }