@less-unsound/eslint-plugin 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 less-unsound contributors
+
+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,112 @@
+# Less Unsound ESLint Plugin
+
+Enforce less unsound TypeScript subset.
+
+## Install
+
+```sh
+pnpm add -D @less-unsound/eslint-plugin eslint typescript @typescript-eslint/parser
+```
+
+## How to use
+
+Some of these rules are overly restrictive, and it's intentional. If you have to break them, the plan is:
+
+- create a separate file, or even a package, that will be a sandbox for this unsafe feature use;
+- make the code as minimal and abstract as possible, so that it can be reused in all similar places;
+- put that code into a sandbox file, and `eslint-ignore` this problem there;
+- make sure to put an explanation, why you had to do this:
+  - for bugs in TypeScript, find or create GitHub issue and link it;
+  - for bugs in EcmaScript design, write why they're impossible to type properly at all;
+- thoroughly cover this code with tests
+  - for type helpers, make sure that arbitrary types make them work the way you intended;
+  - for runtime helpers, write positive/negative tests, use red/green TDD to ensure tests actually fail if you implement it in a different way, try to add property-based tests with `fast-check` and compute coverage if the fix is sufficiently large.
+
+### Example 1
+
+`["a", "b"].includes(x)` doesn't narrow `x` to `'a' | 'b'`. Instead of multiple `x as ('a' | 'b')` over the whole codebase, we can define a wrapper once in `sandbox/array.ts`:
+
+```typescript
+// `extends string` is usually a bad idea, but `key is K` is an even worse idea
+export const includes = <const K extends string>(
+  keys: readonly K[],
+  key: string,
+): key is K => {
+  // we have to do this, otherwise, the next line will complain that `key` isn't `K`
+  const keys1: readonly string[] = keys;
+  return keys1.includes(key);
+};
+```
+
+### Example 2
+
+```typescript
+export const object = <T>(children: { [K in keyof T]: Foo<T[K]> }): Foo<T> => { ... };
+```
+
+- There is no way to type this properly, because, unlike real types, mapped object types have neither proper introduction nor elimination forms.
+- Even though the implementation looks correct, it's overly broad: `T` might be a `number` as well. Possibly a `<T extends object>` would make it better, but most likely it will lead to even more problems.
+- Worse, it might work as you expected when `object({ ... })` call is allowed to infer type of `T`, but will fail in a horrible way if someone does `object</* unexpected type */>({ ... })`.
+- In fact, this whole exception from the rules for `object` might lead to huge problems, because its correctness might rely on the field order in objects, which is not guaranteed by EcmaScript standard.
+
+Probably, a better approach would be a builder that adds fields one by one:
+
+```typescript
+export const Point = object
+  .add('x', number)
+  .add('y', number)
+  .end;
+```
+
+which is barely, but typeable without exceptions.
+
+TL/DR: you must absolutely know what you're doing when you add exceptions.
+
+## Usage
+
+```ts
+import { configs } from "@less-unsound/eslint-plugin";
+
+export default [configs.recommended];
+```
+
+Manual flat-config usage:
+
+```ts
+import { plugin } from "@less-unsound/eslint-plugin";
+
+export default [
+  {
+    plugins: {
+      "@less-unsound": plugin
+    },
+    rules: {
+      "@less-unsound/no-let": "error",
+      "@less-unsound/no-any": "error",
+      "@less-unsound/no-switch": "warn"
+    }
+  }
+];
+```
+
+## Exports
+
+- `plugin`
+- `rules`
+- `configs.mutability`
+- `configs.naming`
+- `configs.oop`
+- `configs.syntax`
+- `configs.types`
+- `configs.recommended`
+
+## Rule Groups
+
+- `configs.mutability`: mutability rules and readonly requirements
+- `configs.naming`: identifier, boolean, filename, and function naming rules
+- `configs.oop`: class, inheritance, proxy, prototype, and similar object-model rules
+- `configs.syntax`: runtime and syntax rules
+- `configs.types`: type-system rules
+- `configs.recommended`: the default combined rule set
+
+Per-rule documentation lives in [docs/rules](./docs/rules).

package/dist/cjs/index.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configs = exports.recommendedConfig = exports.syntaxConfig = exports.typesConfig = exports.namingConfig = exports.oopConfig = exports.mutabilityConfig = exports.plugin = exports.rules = void 0;
+const no_for_let_js_1 = require("./rules/no-for-let.js");
+const no_accidental_mutation_js_1 = require("./rules/no-accidental-mutation.js");
+const no_ambient_dom_globals_js_1 = require("./rules/no-ambient-dom-globals.js");
+const no_arguments_object_js_1 = require("./rules/no-arguments-object.js");
+const no_any_js_1 = require("./rules/no-any.js");
+const no_as_type_assertion_js_1 = require("./rules/no-as-type-assertion.js");
+const no_bigint_js_1 = require("./rules/no-bigint.js");
+const no_boolean_literal_compare_js_1 = require("./rules/no-boolean-literal-compare.js");
+const no_buffer_js_1 = require("./rules/no-buffer.js");
+const no_broad_types_js_1 = require("./rules/no-broad-types.js");
+const no_class_js_1 = require("./rules/no-class.js");
+const no_comma_operator_js_1 = require("./rules/no-comma-operator.js");
+const no_conditional_type_js_1 = require("./rules/no-conditional-type.js");
+const no_default_parameter_js_1 = require("./rules/no-default-parameter.js");
+const no_eval_js_1 = require("./rules/no-eval.js");
+const no_enum_js_1 = require("./rules/no-enum.js");
+const no_export_default_js_1 = require("./rules/no-export-default.js");
+const no_for_in_js_1 = require("./rules/no-for-in.js");
+const no_function_constructor_js_1 = require("./rules/no-function-constructor.js");
+const no_generic_parameter_bounds_js_1 = require("./rules/no-generic-parameter-bounds.js");
+const no_function_keyword_js_1 = require("./rules/no-function-keyword.js");
+const no_getter_setter_js_1 = require("./rules/no-getter-setter.js");
+const no_global_context_js_1 = require("./rules/no-global-context.js");
+const no_in_operator_js_1 = require("./rules/no-in-operator.js");
+const no_indexed_object_type_js_1 = require("./rules/no-indexed-object-type.js");
+const no_indexed_access_type_js_1 = require("./rules/no-indexed-access-type.js");
+const no_import_code_extension_js_1 = require("./rules/no-import-code-extension.js");
+const no_import_rename_js_1 = require("./rules/no-import-rename.js");
+const no_import_type_js_1 = require("./rules/no-import-type.js");
+const no_inheritance_js_1 = require("./rules/no-inheritance.js");
+const no_inline_tagged_object_js_1 = require("./rules/no-inline-tagged-object.js");
+const no_intersection_type_js_1 = require("./rules/no-intersection-type.js");
+const no_json_static_method_js_1 = require("./rules/no-json-static-method.js");
+const no_keyof_js_1 = require("./rules/no-keyof.js");
+const no_let_js_1 = require("./rules/no-let.js");
+const no_mapped_object_type_js_1 = require("./rules/no-mapped-object-type.js");
+const no_never_js_1 = require("./rules/no-never.js");
+const no_non_null_assertion_js_1 = require("./rules/no-non-null-assertion.js");
+const no_null_js_1 = require("./rules/no-null.js");
+const no_object_as_map_js_1 = require("./rules/no-object-as-map.js");
+const no_object_spread_js_1 = require("./rules/no-object-spread.js");
+const no_object_stringification_hook_js_1 = require("./rules/no-object-stringification-hook.js");
+const no_optional_parameter_js_1 = require("./rules/no-optional-parameter.js");
+const no_optional_property_js_1 = require("./rules/no-optional-property.js");
+const no_overload_js_1 = require("./rules/no-overload.js");
+const no_param_assign_js_1 = require("./rules/no-param-assign.js");
+const no_prototype_access_js_1 = require("./rules/no-prototype-access.js");
+const no_proxy_reflect_js_1 = require("./rules/no-proxy-reflect.js");
+const no_require_js_1 = require("./rules/no-require.js");
+const no_regular_expression_js_1 = require("./rules/no-regular-expression.js");
+const no_reexport_outside_entrypoint_js_1 = require("./rules/no-reexport-outside-entrypoint.js");
+const no_rest_parameter_js_1 = require("./rules/no-rest-parameter.js");
+const no_symbol_js_1 = require("./rules/no-symbol.js");
+const no_switch_js_1 = require("./rules/no-switch.js");
+const no_try_catch_js_1 = require("./rules/no-try-catch.js");
+const no_ts_comment_directive_js_1 = require("./rules/no-ts-comment-directive.js");
+const no_tuple_js_1 = require("./rules/no-tuple.js");
+const no_type_guard_js_1 = require("./rules/no-type-guard.js");
+const no_typeof_operator_js_1 = require("./rules/no-typeof-operator.js");
+const no_typeof_type_js_1 = require("./rules/no-typeof-type.js");
+const no_undefined_type_js_1 = require("./rules/no-undefined-type.js");
+const no_unknown_js_1 = require("./rules/no-unknown.js");
+const no_untagged_object_union_js_1 = require("./rules/no-untagged-object-union.js");
+const no_utility_type_js_1 = require("./rules/no-utility-type.js");
+const no_var_js_1 = require("./rules/no-var.js");
+const no_void_operator_js_1 = require("./rules/no-void-operator.js");
+const no_while_js_1 = require("./rules/no-while.js");
+const require_disjoint_union_js_1 = require("./rules/require-disjoint-union.js");
+const require_boolean_prefix_js_1 = require("./rules/require-boolean-prefix.js");
+const require_function_verb_js_1 = require("./rules/require-function-verb.js");
+const require_identifier_case_js_1 = require("./rules/require-identifier-case.js");
+const require_kebab_case_filename_js_1 = require("./rules/require-kebab-case-filename.js");
+const require_named_union_branch_js_1 = require("./rules/require-named-union-branch.js");
+const require_readonly_array_js_1 = require("./rules/require-readonly-array.js");
+const require_readonly_collections_js_1 = require("./rules/require-readonly-collections.js");
+const require_readonly_object_fields_js_1 = require("./rules/require-readonly-object-fields.js");
+const require_return_type_js_1 = require("./rules/require-return-type.js");
+const require_string_template_expression_js_1 = require("./rules/require-string-template-expression.js");
+const require_readonly_tuple_js_1 = require("./rules/require-readonly-tuple.js");
+exports.rules = Object.freeze({
+    "no-for-let": no_for_let_js_1.noForLetRule,
+    "no-accidental-mutation": no_accidental_mutation_js_1.noAccidentalMutationRule,
+    "no-ambient-dom-globals": no_ambient_dom_globals_js_1.noAmbientDomGlobalsRule,
+    "no-arguments-object": no_arguments_object_js_1.noArgumentsObjectRule,
+    "no-any": no_any_js_1.noAnyRule,
+    "no-as-type-assertion": no_as_type_assertion_js_1.noAsTypeAssertionRule,
+    "no-bigint": no_bigint_js_1.noBigintRule,
+    "no-boolean-literal-compare": no_boolean_literal_compare_js_1.noBooleanLiteralCompareRule,
+    "no-buffer": no_buffer_js_1.noBufferRule,
+    "no-broad-types": no_broad_types_js_1.noBroadTypesRule,
+    "no-class": no_class_js_1.noClassRule,
+    "no-comma-operator": no_comma_operator_js_1.noCommaOperatorRule,
+    "no-conditional-type": no_conditional_type_js_1.noConditionalTypeRule,
+    "no-default-parameter": no_default_parameter_js_1.noDefaultParameterRule,
+    "no-eval": no_eval_js_1.noEvalRule,
+    "no-enum": no_enum_js_1.noEnumRule,
+    "no-export-default": no_export_default_js_1.noExportDefaultRule,
+    "no-for-in": no_for_in_js_1.noForInRule,
+    "no-function-constructor": no_function_constructor_js_1.noFunctionConstructorRule,
+    "no-generic-parameter-bounds": no_generic_parameter_bounds_js_1.noGenericParameterBoundsRule,
+    "no-function-keyword": no_function_keyword_js_1.noFunctionKeywordRule,
+    "no-getter-setter": no_getter_setter_js_1.noGetterSetterRule,
+    "no-global-context": no_global_context_js_1.noGlobalContextRule,
+    "no-in-operator": no_in_operator_js_1.noInOperatorRule,
+    "no-indexed-access-type": no_indexed_access_type_js_1.noIndexedAccessTypeRule,
+    "no-indexed-object-type": no_indexed_object_type_js_1.noIndexedObjectTypeRule,
+    "no-import-code-extension": no_import_code_extension_js_1.noImportCodeExtensionRule,
+    "no-import-rename": no_import_rename_js_1.noImportRenameRule,
+    "no-import-type": no_import_type_js_1.noImportTypeRule,
+    "no-inheritance": no_inheritance_js_1.noInheritanceRule,
+    "no-inline-tagged-object": no_inline_tagged_object_js_1.noInlineTaggedObjectRule,
+    "no-intersection-type": no_intersection_type_js_1.noIntersectionTypeRule,
+    "no-json-static-method": no_json_static_method_js_1.noJsonStaticMethodRule,
+    "no-keyof": no_keyof_js_1.noKeyofRule,
+    "no-let": no_let_js_1.noLetRule,
+    "no-mapped-object-type": no_mapped_object_type_js_1.noMappedObjectTypeRule,
+    "no-never": no_never_js_1.noNeverRule,
+    "no-non-null-assertion": no_non_null_assertion_js_1.noNonNullAssertionRule,
+    "no-null": no_null_js_1.noNullRule,
+    "no-object-as-map": no_object_as_map_js_1.noObjectAsMapRule,
+    "no-object-spread": no_object_spread_js_1.noObjectSpreadRule,
+    "no-object-stringification-hook": no_object_stringification_hook_js_1.noObjectStringificationHookRule,
+    "no-optional-parameter": no_optional_parameter_js_1.noOptionalParameterRule,
+    "no-optional-property": no_optional_property_js_1.noOptionalPropertyRule,
+    "no-overload": no_overload_js_1.noOverloadRule,
+    "no-param-assign": no_param_assign_js_1.noParamAssignRule,
+    "no-prototype-access": no_prototype_access_js_1.noPrototypeAccessRule,
+    "no-proxy-reflect": no_proxy_reflect_js_1.noProxyReflectRule,
+    "no-require": no_require_js_1.noRequireRule,
+    "no-reexport-outside-entrypoint": no_reexport_outside_entrypoint_js_1.noReexportOutsideEntrypointRule,
+    "no-regular-expression": no_regular_expression_js_1.noRegularExpressionRule,
+    "no-rest-parameter": no_rest_parameter_js_1.noRestParameterRule,
+    "no-symbol": no_symbol_js_1.noSymbolRule,
+    "no-switch": no_switch_js_1.noSwitchRule,
+    "no-try-catch": no_try_catch_js_1.noTryCatchRule,
+    "no-ts-comment-directive": no_ts_comment_directive_js_1.noTsCommentDirectiveRule,
+    "no-tuple": no_tuple_js_1.noTupleRule,
+    "no-type-guard": no_type_guard_js_1.noTypeGuardRule,
+    "no-typeof-operator": no_typeof_operator_js_1.noTypeofOperatorRule,
+    "no-typeof-type": no_typeof_type_js_1.noTypeofTypeRule,
+    "no-undefined-type": no_undefined_type_js_1.noUndefinedTypeRule,
+    "no-unknown": no_unknown_js_1.noUnknownRule,
+    "no-untagged-object-union": no_untagged_object_union_js_1.noUntaggedObjectUnionRule,
+    "no-utility-type": no_utility_type_js_1.noUtilityTypeRule,
+    "no-var": no_var_js_1.noVarRule,
+    "no-void-operator": no_void_operator_js_1.noVoidOperatorRule,
+    "no-while": no_while_js_1.noWhileRule,
+    "require-disjoint-union": require_disjoint_union_js_1.requireDisjointUnionRule,
+    "require-boolean-prefix": require_boolean_prefix_js_1.requireBooleanPrefixRule,
+    "require-function-verb": require_function_verb_js_1.requireFunctionVerbRule,
+    "require-identifier-case": require_identifier_case_js_1.requireIdentifierCaseRule,
+    "require-kebab-case-filename": require_kebab_case_filename_js_1.requireKebabCaseFilenameRule,
+    "require-named-union-branch": require_named_union_branch_js_1.requireNamedUnionBranchRule,
+    "require-readonly-array": require_readonly_array_js_1.requireReadonlyArrayRule,
+    "require-readonly-collections": require_readonly_collections_js_1.requireReadonlyCollectionsRule,
+    "require-readonly-object-fields": require_readonly_object_fields_js_1.requireReadonlyObjectFieldsRule,
+    "require-return-type": require_return_type_js_1.requireReturnTypeRule,
+    "require-string-template-expression": require_string_template_expression_js_1.requireStringTemplateExpressionRule,
+    "require-readonly-tuple": require_readonly_tuple_js_1.requireReadonlyTupleRule
+});
+const namespace = "@less-unsound";
+const packageName = "@less-unsound/eslint-plugin";
+exports.plugin = Object.freeze({
+    meta: Object.freeze({
+        name: packageName,
+        version: "0.0.1"
+    }),
+    rules: exports.rules
+});
+const createConfig = (entries) => {
+    const namespacedRules = Object.fromEntries(entries.map(([name, level]) => [namespace + "/" + name, level]));
+    return Object.freeze({
+        plugins: Object.freeze({
+            [namespace]: exports.plugin
+        }),
+        rules: Object.freeze(namespacedRules)
+    });
+};
+exports.mutabilityConfig = createConfig([
+    ["no-for-let", "error"],
+    ["no-accidental-mutation", "error"],
+    ["no-let", "error"],
+    ["no-param-assign", "error"],
+    ["no-var", "error"],
+    ["require-readonly-array", "error"],
+    ["require-readonly-collections", "error"],
+    ["require-readonly-object-fields", "error"],
+    ["require-readonly-tuple", "error"]
+]);
+exports.oopConfig = createConfig([
+    ["no-class", "error"],
+    ["no-getter-setter", "error"],
+    ["no-global-context", "error"],
+    ["no-inheritance", "error"],
+    ["no-object-stringification-hook", "error"],
+    ["no-prototype-access", "error"],
+    ["no-proxy-reflect", "error"]
+]);
+exports.namingConfig = createConfig([
+    ["require-boolean-prefix", "error"],
+    ["require-function-verb", "error"],
+    ["require-identifier-case", "error"],
+    ["require-kebab-case-filename", "error"]
+]);
+exports.typesConfig = createConfig([
+    ["no-any", "error"],
+    ["no-as-type-assertion", "error"],
+    ["no-broad-types", "error"],
+    ["no-conditional-type", "error"],
+    ["no-generic-parameter-bounds", "error"],
+    ["no-in-operator", "error"],
+    ["no-indexed-access-type", "error"],
+    ["no-indexed-object-type", "error"],
+    ["no-import-type", "error"],
+    ["no-intersection-type", "error"],
+    ["no-keyof", "error"],
+    ["no-mapped-object-type", "error"],
+    ["no-never", "warn"],
+    ["no-non-null-assertion", "error"],
+    ["no-tuple", "error"],
+    ["no-optional-property", "error"],
+    ["no-symbol", "error"],
+    ["no-overload", "error"],
+    ["no-ts-comment-directive", "error"],
+    ["no-type-guard", "error"],
+    ["no-typeof-operator", "error"],
+    ["no-typeof-type", "error"],
+    ["no-undefined-type", "warn"],
+    ["no-unknown", "error"],
+    ["no-utility-type", "error"],
+    ["require-disjoint-union", "error"],
+    ["require-named-union-branch", "error"],
+    ["require-return-type", "error"]
+]);
+exports.syntaxConfig = createConfig([
+    ["no-ambient-dom-globals", "error"],
+    ["no-arguments-object", "error"],
+    ["no-default-parameter", "error"],
+    ["no-eval", "error"],
+    ["no-enum", "error"],
+    ["no-export-default", "error"],
+    ["no-for-in", "error"],
+    ["no-function-constructor", "error"],
+    ["no-function-keyword", "error"],
+    ["no-boolean-literal-compare", "error"],
+    ["no-buffer", "error"],
+    ["no-comma-operator", "error"],
+    ["no-inline-tagged-object", "error"],
+    ["no-json-static-method", "error"],
+    ["no-import-code-extension", "error"],
+    ["no-import-rename", "error"],
+    ["no-null", "error"],
+    ["no-object-as-map", "error"],
+    ["no-object-spread", "error"],
+    ["no-optional-parameter", "error"],
+    ["no-reexport-outside-entrypoint", "error"],
+    ["no-require", "error"],
+    ["no-regular-expression", "error"],
+    ["no-rest-parameter", "error"],
+    ["no-try-catch", "error"],
+    ["no-void-operator", "error"],
+    ["no-while", "error"],
+    ["require-string-template-expression", "error"]
+]);
+exports.recommendedConfig = createConfig([
+    ["no-for-let", "error"],
+    ["no-any", "error"],
+    ["no-as-type-assertion", "error"],
+    ["no-accidental-mutation", "error"],
+    ["no-ambient-dom-globals", "error"],
+    ["no-arguments-object", "error"],
+    ["no-bigint", "warn"],
+    ["no-boolean-literal-compare", "error"],
+    ["no-buffer", "error"],
+    ["no-broad-types", "error"],
+    ["no-class", "error"],
+    ["no-comma-operator", "error"],
+    ["no-conditional-type", "error"],
+    ["no-default-parameter", "error"],
+    ["no-eval", "error"],
+    ["no-enum", "error"],
+    ["no-export-default", "error"],
+    ["no-for-in", "error"],
+    ["no-function-constructor", "error"],
+    ["no-function-keyword", "error"],
+    ["no-inline-tagged-object", "error"],
+    ["no-generic-parameter-bounds", "error"],
+    ["no-getter-setter", "error"],
+    ["no-global-context", "error"],
+    ["no-in-operator", "error"],
+    ["no-indexed-access-type", "error"],
+    ["no-indexed-object-type", "error"],
+    ["no-import-code-extension", "error"],
+    ["no-import-rename", "error"],
+    ["no-import-type", "error"],
+    ["no-inheritance", "error"],
+    ["no-intersection-type", "error"],
+    ["no-json-static-method", "error"],
+    ["no-keyof", "error"],
+    ["no-let", "error"],
+    ["no-mapped-object-type", "error"],
+    ["no-never", "warn"],
+    ["no-non-null-assertion", "error"],
+    ["no-null", "error"],
+    ["no-object-as-map", "error"],
+    ["no-object-spread", "error"],
+    ["no-object-stringification-hook", "error"],
+    ["no-optional-parameter", "error"],
+    ["no-optional-property", "error"],
+    ["no-overload", "error"],
+    ["no-param-assign", "error"],
+    ["no-prototype-access", "error"],
+    ["no-proxy-reflect", "error"],
+    ["no-reexport-outside-entrypoint", "error"],
+    ["no-require", "error"],
+    ["no-regular-expression", "error"],
+    ["no-rest-parameter", "error"],
+    ["no-symbol", "error"],
+    ["no-switch", "warn"],
+    ["no-try-catch", "error"],
+    ["no-ts-comment-directive", "error"],
+    ["no-tuple", "error"],
+    ["no-type-guard", "error"],
+    ["no-typeof-operator", "error"],
+    ["no-typeof-type", "error"],
+    ["no-undefined-type", "warn"],
+    ["no-unknown", "error"],
+    ["no-utility-type", "error"],
+    ["no-var", "error"],
+    ["no-void-operator", "error"],
+    ["no-while", "error"],
+    ["require-boolean-prefix", "error"],
+    ["require-disjoint-union", "error"],
+    ["require-function-verb", "error"],
+    ["require-identifier-case", "error"],
+    ["require-kebab-case-filename", "error"],
+    ["require-named-union-branch", "error"],
+    ["require-readonly-array", "error"],
+    ["require-readonly-collections", "error"],
+    ["require-readonly-object-fields", "error"],
+    ["require-return-type", "error"],
+    ["require-string-template-expression", "error"],
+    ["require-readonly-tuple", "off"]
+]);
+exports.configs = Object.freeze({
+    mutability: exports.mutabilityConfig,
+    naming: exports.namingConfig,
+    oop: exports.oopConfig,
+    recommended: exports.recommendedConfig,
+    syntax: exports.syntaxConfig,
+    types: exports.typesConfig
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/rules/no-accidental-mutation.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noAccidentalMutationRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const create_rule_js_1 = require("../utils/create-rule.js");
+const freshArrayMethods = new Set([
+    "concat",
+    "filter",
+    "flat",
+    "flatMap",
+    "map",
+    "slice",
+    "toReversed",
+    "toSorted",
+    "toSpliced"
+]);
+const mutatingMethods = new Set(["reverse", "sort", "splice"]);
+const messageIds = Object.freeze({
+    forbiddenAccidentalMutation: "Accidental array mutation is not allowed on non-fresh arrays unless mutability is required for performance."
+});
+const getMemberName = (node) => {
+    if (node.computed) {
+        return undefined;
+    }
+    if (node.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return undefined;
+    }
+    return node.property.name;
+};
+const isArrayFactoryCall = (node) => {
+    if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const memberName = getMemberName(node.callee);
+    if (memberName !== "from" && memberName !== "of") {
+        return false;
+    }
+    if (node.callee.object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return node.callee.object.name === "Array";
+};
+const isFreshArrayExpression = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+        return true;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+        if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return false;
+        }
+        return node.callee.name === "Array";
+    }
+    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+        return false;
+    }
+    if (isArrayFactoryCall(node)) {
+        return true;
+    }
+    if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const memberName = getMemberName(node.callee);
+    if (memberName === undefined) {
+        return false;
+    }
+    return freshArrayMethods.has(memberName);
+};
+exports.noAccidentalMutationRule = (0, create_rule_js_1.createRule)({
+    name: "no-accidental-mutation",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow in-place `.sort()`, `.reverse()`, and `.splice()` on non-fresh arrays unless mutability is required for performance."
+        },
+        schema: [],
+        messages: messageIds
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        CallExpression: (node) => {
+            if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return;
+            }
+            const memberName = getMemberName(node.callee);
+            if (memberName === undefined) {
+                return;
+            }
+            if (!mutatingMethods.has(memberName)) {
+                return;
+            }
+            if (isFreshArrayExpression(node.callee.object)) {
+                return;
+            }
+            context.report({
+                node,
+                messageId: "forbiddenAccidentalMutation"
+            });
+        }
+    })
+});