oxlint-plugin-immutable 0.1.1

package/README.md

@@ -0,0 +1,68 @@
+# oxlint-plugin-immutable
+
+Immutability and functional-style lint rules ported from [eslint-plugin-functional](https://github.com/eslint-functional/eslint-plugin-functional) to [Oxlint's JS plugin API](https://oxc.rs/docs/guide/usage/linter/plugins). Also works with ESLint flat config via the bundled `eslintCompatPlugin` wrapper.
+
+> **Note:** Rules that require the TypeScript type checker (deep immutability analysis) are not implemented — Oxlint's JS plugin API operates on AST only. The `prefer-immutable-types` rule uses `ReadonlyShallow` enforcement mode, and `type-declaration-immutability` uses structural AST analysis.
+
+## Requirements
+
+- Oxlint `>= 1.0.0` (requires `jsPlugins` support)
+- Node.js `>= 18`
+
+## Installation
+
+```sh
+npm add -D oxlint-plugin-immutable
+# or
+bun add -d oxlint-plugin-immutable
+```
+
+## Usage with Oxlint
+
+Add the plugin to `jsPlugins` and enable the rules you want:
+
+```json
+// .oxlintrc.json
+{
+  "jsPlugins": ["./node_modules/oxlint-plugin-immutable/dist/index.js"],
+  "rules": {
+    "oxlint-plugin-immutable/no-let": "error",
+    "oxlint-plugin-immutable/no-throw-statements": "error",
+    "oxlint-plugin-immutable/type-declaration-immutability": "error",
+    "oxlint-plugin-immutable/immutable-data": "error"
+  }
+}
+```
+
+## Usage with ESLint
+
+```js
+// eslint.config.mjs
+import immutablePlugin from "oxlint-plugin-immutable/dist/index.js";
+
+export default [
+  {
+    plugins: { functional: immutablePlugin },
+    rules: immutablePlugin.configs.recommended.rules,
+  },
+];
+```
+
+## Rules
+
+The **Recommended** column shows the severity used in `plugin.configs.recommended`. Rules with `—` are implemented but not included in the recommended config.
+
+| Rule | Description | Recommended |
+|---|---|---|
+| `no-let` | Disallow `let` declarations — prefer `const` | error |
+| `no-throw-statements` | Disallow `throw` statements | error |
+| `prefer-property-signatures` | Prefer property signatures over method signatures in types | error |
+| `prefer-immutable-types` | Enforce `ReadonlyShallow` on parameters, return types, and variables (AST-only) | error |
+| `type-declaration-immutability` | Type aliases and interfaces must be at least `ReadonlyShallow` | error |
+| `no-promise-reject` | Disallow `Promise.reject()` | — |
+| `immutable-data` | Disallow mutating methods on arrays/objects (`push`, `splice`, etc.) | — |
+| `readonly-type` | Enforce `readonly` on TypeScript type members | — |
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,801 @@
+// node_modules/.bun/@oxlint+plugins@1.43.0/node_modules/@oxlint/plugins/index.js
+var EMPTY_VISITOR = {};
+function eslintCompatPlugin(plugin) {
+  if (typeof plugin != "object" || !plugin)
+    throw Error("Plugin must be an object");
+  let { rules } = plugin;
+  if (typeof rules != "object" || !rules)
+    throw Error("Plugin must have an object as `rules` property");
+  for (let ruleName in rules)
+    Object.hasOwn(rules, ruleName) && convertRule(rules[ruleName]);
+  return plugin;
+}
+function convertRule(rule) {
+  if (typeof rule != "object" || !rule)
+    throw Error("Rule must be an object");
+  if ("create" in rule)
+    return;
+  let context = null, visitor, beforeHook;
+  rule.create = (eslintContext) => (context === null && ({ context, visitor, beforeHook } = createContextAndVisitor(rule)), Object.defineProperties(context, {
+    id: { value: eslintContext.id },
+    options: { value: eslintContext.options },
+    report: { value: eslintContext.report }
+  }), Object.setPrototypeOf(context, Object.getPrototypeOf(eslintContext)), beforeHook !== null && beforeHook() === false ? EMPTY_VISITOR : visitor);
+}
+var FILE_CONTEXT = Object.freeze({
+  get filename() {
+    throw Error("Cannot access `context.filename` in `createOnce`");
+  },
+  getFilename() {
+    throw Error("Cannot call `context.getFilename` in `createOnce`");
+  },
+  get physicalFilename() {
+    throw Error("Cannot access `context.physicalFilename` in `createOnce`");
+  },
+  getPhysicalFilename() {
+    throw Error("Cannot call `context.getPhysicalFilename` in `createOnce`");
+  },
+  get cwd() {
+    throw Error("Cannot access `context.cwd` in `createOnce`");
+  },
+  getCwd() {
+    throw Error("Cannot call `context.getCwd` in `createOnce`");
+  },
+  get sourceCode() {
+    throw Error("Cannot access `context.sourceCode` in `createOnce`");
+  },
+  getSourceCode() {
+    throw Error("Cannot call `context.getSourceCode` in `createOnce`");
+  },
+  get languageOptions() {
+    throw Error("Cannot access `context.languageOptions` in `createOnce`");
+  },
+  get settings() {
+    throw Error("Cannot access `context.settings` in `createOnce`");
+  },
+  extend(extension) {
+    return Object.freeze(Object.assign(Object.create(this), extension));
+  },
+  get parserOptions() {
+    throw Error("Cannot access `context.parserOptions` in `createOnce`");
+  },
+  get parserPath() {
+    throw Error("Cannot access `context.parserPath` in `createOnce`");
+  }
+});
+function createContextAndVisitor(rule) {
+  let { createOnce } = rule;
+  if (createOnce == null)
+    throw Error("Rules must define either a `create` or `createOnce` method");
+  if (typeof createOnce != "function")
+    throw Error("Rule `createOnce` property must be a function");
+  let context = Object.create(FILE_CONTEXT, {
+    id: {
+      value: "",
+      enumerable: true,
+      configurable: true
+    },
+    options: {
+      value: null,
+      enumerable: true,
+      configurable: true
+    },
+    report: {
+      value: null,
+      enumerable: true,
+      configurable: true
+    }
+  }), { before: beforeHook, after: afterHook, ...visitor } = createOnce.call(rule, context);
+  if (beforeHook === undefined)
+    beforeHook = null;
+  else if (beforeHook !== null && typeof beforeHook != "function")
+    throw Error("`before` property of visitor must be a function if defined");
+  if (afterHook != null) {
+    if (typeof afterHook != "function")
+      throw Error("`after` property of visitor must be a function if defined");
+    let maxAttrs = -1;
+    for (let key2 in visitor) {
+      if (!Object.hasOwn(visitor, key2) || !key2.endsWith(":exit"))
+        continue;
+      let end = key2.length - 5, count = 0;
+      for (let i = 0;i < end; i++) {
+        let c = key2.charCodeAt(i);
+        (c === 91 || c === 46 || c === 58) && count++;
+      }
+      count > maxAttrs && (maxAttrs = count);
+    }
+    let key = `Program${"[type]".repeat(maxAttrs + 1)}:exit`;
+    visitor[key] = (_node) => afterHook();
+  }
+  return {
+    context,
+    visitor,
+    beforeHook
+  };
+}
+
+// packages/plugin-functional/src/utils/ignore.ts
+function asPatterns(pattern) {
+  if (pattern == null) {
+    return [];
+  }
+  const values = Array.isArray(pattern) ? pattern : [pattern];
+  return values.map((value) => new RegExp(value, "u"));
+}
+function shouldIgnorePattern(name, pattern) {
+  if (!name) {
+    return false;
+  }
+  const patterns = asPatterns(pattern);
+  return patterns.some((regex) => regex.test(name));
+}
+function isIgnoredViaIdentifierPattern(node, pattern) {
+  if (!node) {
+    return false;
+  }
+  if (node.type === "Identifier") {
+    return shouldIgnorePattern(node.name, pattern);
+  }
+  if (node.type === "MemberExpression" && node.property?.type === "Identifier") {
+    return shouldIgnorePattern(node.property.name, pattern);
+  }
+  return false;
+}
+
+// packages/plugin-functional/src/rules/immutable-data.ts
+var arrayMutators = new Set(["copyWithin", "fill", "pop", "push", "reverse", "shift", "sort", "splice", "unshift"]);
+var mapAndSetMutators = new Set(["add", "clear", "delete", "set"]);
+function isInsideClass(node) {
+  let current = node?.parent;
+  while (current) {
+    if (current.type === "ClassBody" || current.type === "ClassDeclaration" || current.type === "ClassExpression") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isImmediateMutation(node) {
+  const root = findRootExpression(node);
+  return root?.type === "ObjectExpression" || root?.type === "ArrayExpression";
+}
+function findRootExpression(node) {
+  let current = node;
+  while (current?.type === "MemberExpression") {
+    current = current.object;
+  }
+  return current;
+}
+function getMutatorName(node) {
+  if (node.callee?.type !== "MemberExpression") {
+    return null;
+  }
+  if (node.callee.property?.type === "Identifier") {
+    return node.callee.property.name;
+  }
+  return null;
+}
+var immutable_data_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow mutating existing data structures.",
+      recommended: "error"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignoreClasses: { type: "boolean" },
+          ignoreMapsAndSets: { type: "boolean" },
+          ignoreImmediateMutation: { type: "boolean" },
+          ignoreNonConstDeclarations: { type: "boolean" },
+          ignoreIdentifierPattern: {
+            anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      generic: "Modifying an existing object/array is not allowed.",
+      object: "Modifying properties of an existing object is not allowed.",
+      array: "Modifying an array is not allowed.",
+      map: "Modifying a map is not allowed.",
+      set: "Modifying a set is not allowed."
+    }
+  },
+  defaultOptions: [
+    {
+      ignoreClasses: false,
+      ignoreMapsAndSets: false,
+      ignoreImmediateMutation: true,
+      ignoreNonConstDeclarations: false
+    }
+  ],
+  createOnce(context) {
+    const getOpts = () => context.options?.[0] ?? {};
+    const shouldIgnoreNode = (node) => {
+      const options = getOpts();
+      if (options?.ignoreClasses && isInsideClass(node)) {
+        return true;
+      }
+      if (options?.ignoreImmediateMutation && isImmediateMutation(node)) {
+        return true;
+      }
+      if (isIgnoredViaIdentifierPattern(findRootExpression(node), options?.ignoreIdentifierPattern)) {
+        return true;
+      }
+      return false;
+    };
+    return {
+      AssignmentExpression(node) {
+        if (node.left?.type !== "MemberExpression" || shouldIgnoreNode(node.left)) {
+          return;
+        }
+        context.report({ node, messageId: "generic" });
+      },
+      UnaryExpression(node) {
+        if (node.operator !== "delete" || node.argument?.type !== "MemberExpression" || shouldIgnoreNode(node.argument)) {
+          return;
+        }
+        context.report({ node, messageId: "generic" });
+      },
+      UpdateExpression(node) {
+        if (node.argument?.type !== "MemberExpression" || shouldIgnoreNode(node.argument)) {
+          return;
+        }
+        context.report({ node, messageId: "generic" });
+      },
+      CallExpression(node) {
+        const mutator = getMutatorName(node);
+        if (!mutator || node.callee?.type !== "MemberExpression" || shouldIgnoreNode(node.callee)) {
+          return;
+        }
+        if (arrayMutators.has(mutator)) {
+          context.report({ node, messageId: "array" });
+          return;
+        }
+        if (mapAndSetMutators.has(mutator)) {
+          if (getOpts()?.ignoreMapsAndSets) {
+            return;
+          }
+          context.report({ node, messageId: mutator === "add" ? "set" : "map" });
+        }
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/utils/tree.ts
+function getEnclosingFunction(node) {
+  let current = node?.parent;
+  while (current != null) {
+    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function isInForLoopInitializer(node) {
+  const parent = node?.parent;
+  if (parent?.type === "ForStatement") {
+    return parent.init === node;
+  }
+  if (parent?.type === "ForInStatement" || parent?.type === "ForOfStatement") {
+    return parent.left === node;
+  }
+  return false;
+}
+
+// packages/plugin-functional/src/rules/no-let.ts
+var no_let_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow mutable variables declared with let.",
+      recommended: "error"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowInForLoopInit: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      generic: "Unexpected let, use const instead."
+    }
+  },
+  defaultOptions: [{ allowInForLoopInit: false }],
+  createOnce(context) {
+    return {
+      VariableDeclaration(node) {
+        if (node.kind !== "let") {
+          return;
+        }
+        const allowInForLoopInit = context.options?.[0]?.allowInForLoopInit === true;
+        if (allowInForLoopInit && isInForLoopInitializer(node)) {
+          return;
+        }
+        context.report({ node, messageId: "generic" });
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/rules/no-promise-reject.ts
+var no_promise_reject_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow Promise.reject and reject callbacks.",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      generic: "Unexpected rejection, resolve an error instead."
+    }
+  },
+  defaultOptions: [{}],
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === "Promise" && node.callee.property?.type === "Identifier" && node.callee.property.name === "reject") {
+          context.report({ node, messageId: "generic" });
+        }
+      },
+      NewExpression(node) {
+        if (node.callee?.type !== "Identifier" || node.callee.name !== "Promise") {
+          return;
+        }
+        const firstArg = node.arguments?.[0];
+        if ((firstArg?.type === "ArrowFunctionExpression" || firstArg?.type === "FunctionExpression") && firstArg.params?.[1]) {
+          context.report({ node: firstArg.params[1], messageId: "generic" });
+        }
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/rules/no-throw-statements.ts
+var no_throw_statements_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow throw statements.",
+      recommended: "error"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowInAsyncFunctions: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      generic: "Unexpected throw, throwing exceptions is not functional."
+    }
+  },
+  defaultOptions: [{ allowInAsyncFunctions: false }],
+  createOnce(context) {
+    return {
+      ThrowStatement(node) {
+        const allowInAsyncFunctions = context.options?.[0]?.allowInAsyncFunctions === true;
+        if (allowInAsyncFunctions) {
+          const fn = getEnclosingFunction(node);
+          if (fn?.async === true) {
+            return;
+          }
+        }
+        context.report({ node, messageId: "generic" });
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/utils/immutability.ts
+function isIdentifierTypeReference(node, name) {
+  return node?.type === "TSTypeReference" && node.typeName?.type === "Identifier" && node.typeName.name === name;
+}
+function hasReadonlyModifier(property) {
+  if (!property) {
+    return false;
+  }
+  if (property.type === "TSPropertySignature" || property.type === "TSIndexSignature") {
+    return property.readonly === true;
+  }
+  return false;
+}
+function isReadonlyArrayType(typeNode) {
+  if (!typeNode) {
+    return false;
+  }
+  if (typeNode.type === "TSArrayType") {
+    return false;
+  }
+  if (typeNode.type === "TSTypeOperator" && typeNode.operator === "readonly" && typeNode.typeAnnotation?.type === "TSArrayType") {
+    return true;
+  }
+  if (isIdentifierTypeReference(typeNode, "ReadonlyArray")) {
+    return true;
+  }
+  if (isIdentifierTypeReference(typeNode, "ReadonlyMap") || isIdentifierTypeReference(typeNode, "ReadonlySet")) {
+    return true;
+  }
+  return false;
+}
+function isMemberReadonly(member) {
+  if (!member) {
+    return true;
+  }
+  if (member.type === "TSPropertySignature") {
+    if (!member.readonly) {
+      return false;
+    }
+    if (member.typeAnnotation?.typeAnnotation?.type === "TSArrayType") {
+      return false;
+    }
+    if (member.typeAnnotation?.typeAnnotation && member.typeAnnotation.typeAnnotation.type !== "TSArrayType" && !isReadonlyArrayType(member.typeAnnotation.typeAnnotation) && (member.typeAnnotation.typeAnnotation.type === "TSTypeReference" || member.typeAnnotation.typeAnnotation.type === "TSArrayType" || member.typeAnnotation.typeAnnotation.type === "TSTypeOperator")) {
+      const typeNode = member.typeAnnotation.typeAnnotation;
+      if (typeNode.type === "TSArrayType") {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (member.type === "TSIndexSignature") {
+    return member.readonly === true;
+  }
+  return true;
+}
+function isShallowReadonly(typeNode) {
+  if (!typeNode) {
+    return false;
+  }
+  if (isReadonlyArrayType(typeNode)) {
+    return true;
+  }
+  if (typeNode.type === "TSTypeLiteral") {
+    return typeNode.members.every((member) => isMemberReadonly(member));
+  }
+  if (typeNode.type === "TSInterfaceBody") {
+    return typeNode.body.every((member) => isMemberReadonly(member));
+  }
+  return false;
+}
+
+// packages/plugin-functional/src/rules/prefer-immutable-types.ts
+function getCategoryOption(option, key) {
+  const value = option?.[key] ?? {};
+  return {
+    enforcement: value.enforcement ?? "ReadonlyShallow",
+    ignoreNamePattern: value.ignoreNamePattern
+  };
+}
+function getParamName(param) {
+  if (param?.type === "Identifier") {
+    return param.name;
+  }
+  return;
+}
+function reportIfNotShallowReadonly(context, node, typeNode, messageId, ignoreNamePattern, name) {
+  if (ignoreNamePattern && shouldIgnorePattern(name, ignoreNamePattern)) {
+    return;
+  }
+  if (!typeNode || !isShallowReadonly(typeNode)) {
+    context.report({ node, messageId });
+  }
+}
+var prefer_immutable_types_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require shallow readonly types for parameters, return types, and variables.",
+      recommended: "error"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          parameters: { type: "object" },
+          returnTypes: { type: "object" },
+          variables: { type: "object" }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      parameter: "Parameter should be typed as ReadonlyShallow.",
+      returnType: "Return type should be typed as ReadonlyShallow.",
+      variable: "Variable should be typed as ReadonlyShallow.",
+      property: "Property should be typed as ReadonlyShallow."
+    }
+  },
+  defaultOptions: [
+    {
+      parameters: { enforcement: "ReadonlyShallow" },
+      returnTypes: { enforcement: "ReadonlyShallow" },
+      variables: { enforcement: "ReadonlyShallow" }
+    }
+  ],
+  createOnce(context) {
+    const getOpts = () => {
+      const option = context.options?.[0] ?? {};
+      return {
+        parameters: getCategoryOption(option, "parameters"),
+        returnTypes: getCategoryOption(option, "returnTypes"),
+        variables: getCategoryOption(option, "variables")
+      };
+    };
+    const checkFunction = (node) => {
+      const { parameters, returnTypes } = getOpts();
+      if (parameters.enforcement === "ReadonlyShallow") {
+        for (const param of node.params ?? []) {
+          const typeNode = param?.typeAnnotation?.typeAnnotation;
+          reportIfNotShallowReadonly(context, param, typeNode, "parameter", parameters.ignoreNamePattern, getParamName(param));
+        }
+      }
+      if (returnTypes.enforcement === "ReadonlyShallow") {
+        const typeNode = node.returnType?.typeAnnotation;
+        reportIfNotShallowReadonly(context, node, typeNode, "returnType", returnTypes.ignoreNamePattern);
+      }
+    };
+    return {
+      FunctionDeclaration: checkFunction,
+      FunctionExpression: checkFunction,
+      ArrowFunctionExpression: checkFunction,
+      TSPropertySignature(node) {
+        const { variables } = getOpts();
+        if (variables.enforcement !== "ReadonlyShallow") {
+          return;
+        }
+        const typeNode = node.typeAnnotation?.typeAnnotation;
+        const name = node.key?.type === "Identifier" ? node.key.name : undefined;
+        reportIfNotShallowReadonly(context, node, typeNode, "property", variables.ignoreNamePattern, name);
+      },
+      VariableDeclarator(node) {
+        const { variables } = getOpts();
+        if (variables.enforcement !== "ReadonlyShallow") {
+          return;
+        }
+        const typeNode = node.id?.typeAnnotation?.typeAnnotation;
+        const name = node.id?.type === "Identifier" ? node.id.name : undefined;
+        reportIfNotShallowReadonly(context, node, typeNode, "variable", variables.ignoreNamePattern, name);
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/rules/prefer-property-signatures.ts
+function hasReadonlyWrapper(node) {
+  let current = node?.parent;
+  while (current) {
+    if (current.type === "TSTypeReference" && current.typeName?.type === "Identifier" && current.typeName.name === "Readonly") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+var prefer_property_signatures_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer property signatures over method signatures.",
+      recommended: "error"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignoreIfReadonlyWrapped: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    fixable: "code",
+    messages: {
+      generic: "Use a property signature instead of a method signature."
+    }
+  },
+  defaultOptions: [{ ignoreIfReadonlyWrapped: false }],
+  createOnce(context) {
+    return {
+      TSMethodSignature(node) {
+        const ignoreIfReadonlyWrapped = context.options?.[0]?.ignoreIfReadonlyWrapped === true;
+        if (ignoreIfReadonlyWrapped && hasReadonlyWrapper(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "generic",
+          fix(fixer) {
+            const sourceCode = context.sourceCode;
+            const keyText = sourceCode.getText(node.key);
+            const optional = node.optional ? "?" : "";
+            const typeParams = node.typeParameters ? sourceCode.getText(node.typeParameters) : "";
+            const params = node.params.map((param) => sourceCode.getText(param)).join(", ");
+            const returnType = node.returnType ? sourceCode.getText(node.returnType.typeAnnotation) : "void";
+            const replacement = `${keyText}${optional}: ${typeParams}(${params}) => ${returnType}`;
+            return fixer.replaceText(node, replacement);
+          }
+        });
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/rules/readonly-type.ts
+var readonly_type_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require readonly modifier on type literal properties.",
+      recommended: "error"
+    },
+    schema: [],
+    fixable: "code",
+    messages: {
+      missingReadonly: "Property should have a readonly modifier."
+    }
+  },
+  defaultOptions: [],
+  createOnce(context) {
+    return {
+      TSTypeLiteral(node) {
+        for (const member of node.members ?? []) {
+          if ((member.type === "TSPropertySignature" || member.type === "TSIndexSignature") && member.readonly !== true) {
+            context.report({
+              node: member,
+              messageId: "missingReadonly",
+              fix(fixer) {
+                return fixer.insertTextBefore(member, "readonly ");
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/rules/type-declaration-immutability.ts
+function membersAreReadonly(members) {
+  return members.every((member) => {
+    if (member.type === "TSPropertySignature") {
+      if (!hasReadonlyModifier(member)) {
+        return false;
+      }
+      const typeNode = member.typeAnnotation?.typeAnnotation;
+      if (typeNode?.type === "TSArrayType") {
+        return false;
+      }
+      if (typeNode && typeNode.type !== "TSArrayType" && typeNode.type !== "TSTypeLiteral") {
+        if (typeNode.type === "TSTypeReference" || typeNode.type === "TSTypeOperator") {
+          if (typeNode.type === "TSTypeOperator" && typeNode.operator === "readonly") {
+            return true;
+          }
+          if (isReadonlyArrayType(typeNode)) {
+            return true;
+          }
+        }
+      }
+      return true;
+    }
+    if (member.type === "TSIndexSignature") {
+      return hasReadonlyModifier(member);
+    }
+    return true;
+  });
+}
+function shouldCheckName(name, identifiers) {
+  if (!identifiers) {
+    return true;
+  }
+  return !shouldIgnorePattern(name, identifiers);
+}
+var type_declaration_immutability_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce ReadonlyShallow immutability on type declarations.",
+      recommended: "error"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          identifiers: {
+            anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+          },
+          ignoreInterfaces: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      notReadonly: "Type declaration should be at least ReadonlyShallow."
+    }
+  },
+  defaultOptions: [{ ignoreInterfaces: false }],
+  createOnce(context) {
+    const getOpts = () => context.options?.[0] ?? {};
+    return {
+      TSTypeAliasDeclaration(node) {
+        const option = getOpts();
+        const name = node.id?.name;
+        if (!shouldCheckName(name, option?.identifiers)) {
+          return;
+        }
+        const typeAnnotation = node.typeAnnotation;
+        if (typeAnnotation?.type === "TSTypeLiteral") {
+          if (!membersAreReadonly(typeAnnotation.members ?? [])) {
+            context.report({ node, messageId: "notReadonly" });
+          }
+          return;
+        }
+        if (typeAnnotation?.type === "TSIntersectionType") {
+          const literalConstituents = (typeAnnotation.types ?? []).filter((t) => t.type === "TSTypeLiteral");
+          if (literalConstituents.length === 0) {
+            return;
+          }
+          for (const literal of literalConstituents) {
+            if (!membersAreReadonly(literal.members ?? [])) {
+              context.report({ node, messageId: "notReadonly" });
+              return;
+            }
+          }
+        }
+      },
+      TSInterfaceDeclaration(node) {
+        const option = getOpts();
+        if (option?.ignoreInterfaces === true) {
+          return;
+        }
+        const name = node.id?.name;
+        if (!shouldCheckName(name, option?.identifiers)) {
+          return;
+        }
+        if (!membersAreReadonly(node.body?.body ?? [])) {
+          context.report({ node, messageId: "notReadonly" });
+        }
+      }
+    };
+  }
+};
+
+// packages/plugin-functional/src/index.ts
+var plugin = eslintCompatPlugin({
+  meta: { name: "oxlint-plugin-immutable" },
+  rules: {
+    "no-let": no_let_default,
+    "no-throw-statements": no_throw_statements_default,
+    "prefer-property-signatures": prefer_property_signatures_default,
+    "prefer-immutable-types": prefer_immutable_types_default,
+    "type-declaration-immutability": type_declaration_immutability_default,
+    "no-promise-reject": no_promise_reject_default,
+    "immutable-data": immutable_data_default,
+    "readonly-type": readonly_type_default
+  },
+  configs: {
+    recommended: {
+      rules: {
+        "functional/no-let": "error",
+        "functional/no-throw-statements": "error",
+        "functional/prefer-property-signatures": "error",
+        "functional/prefer-immutable-types": ["error", { parameters: { enforcement: "ReadonlyShallow" } }],
+        "functional/type-declaration-immutability": ["error", { ignoreInterfaces: false }]
+      }
+    }
+  }
+});
+var src_default = plugin;
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "oxlint-plugin-immutable",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Immutability lint rules ported from eslint-plugin-functional to Oxlint's JS plugin API. Also compatible with ESLint flat config.",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "oxlint",
+    "eslint",
+    "functional",
+    "immutability",
+    "readonly",
+    "lint"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/takinprofit/biome-plugins"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}