oxlint-plugin-ts-no-assert 0.1.1

package/README.md

@@ -0,0 +1,77 @@
+# oxlint-plugin-ts-no-assert
+
+Disallow TypeScript type assertions (`as`, angle-bracket `<Type>`, and non-null `!`) — ported from [eslint-plugin-no-type-assertion](https://github.com/Dremora/eslint-plugin-no-type-assertion) 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.
+
+## Requirements
+
+- Oxlint `>= 1.0.0` (requires `jsPlugins` support)
+- Node.js `>= 18`
+
+## Installation
+
+```sh
+npm add -D oxlint-plugin-ts-no-assert
+# or
+bun add -d oxlint-plugin-ts-no-assert
+```
+
+## Usage with Oxlint
+
+Add the plugin to `jsPlugins` and enable the rule:
+
+```json
+// .oxlintrc.json
+{
+  "jsPlugins": ["./node_modules/oxlint-plugin-ts-no-assert/dist/index.js"],
+  "rules": {
+    "oxlint-plugin-ts-no-assert/no-type-assertion": "error"
+  }
+}
+```
+
+## Usage with ESLint
+
+```js
+// eslint.config.mjs
+import tsNoAssertPlugin from "oxlint-plugin-ts-no-assert/dist/index.js";
+
+export default [
+  {
+    plugins: { "no-type-assertion": tsNoAssertPlugin },
+    rules: tsNoAssertPlugin.configs.recommended.rules,
+  },
+];
+```
+
+## Rules
+
+### `no-type-assertion/no-type-assertion`
+
+Disallows all three forms of TypeScript type assertion.
+
+**Forbidden:**
+
+```ts
+const x = value as MyType;     // ❌ Do not use `as` operator for type assertion
+const x = <MyType>value;       // ❌ Do not use type assertion (angle-bracket)
+const x = maybeNull!;          // ❌ Do not use non-null assertion operator
+```
+
+**Allowed** — safe widening that TypeScript itself endorses:
+
+```ts
+const x = value as unknown;    // ✅ widening to unknown is safe
+const x = value as const;      // ✅ const assertion
+const x = <unknown>value;      // ✅
+const x = <const>value;        // ✅
+```
+
+> **Note on angle-bracket syntax:** TypeScript disallows `<Type>value` in `.tsx` files because it is syntactically ambiguous with JSX. The `angleBracketAssertion` diagnostic will only appear in plain `.ts` files.
+
+| Rule | Description | Recommended |
+|---|---|---|
+| `no-type-assertion` | Disallow `as`, `<Type>`, and `!` type assertions (except `as const` / `as unknown`) | error |
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,180 @@
+// 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-no-type-assertion/src/rules/no-type-assertion.ts
+function isAllowedTypeAnnotation(typeAnnotation) {
+  if (typeAnnotation.type === "TSUnknownKeyword") {
+    return true;
+  }
+  if (typeAnnotation.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName?.name === "const") {
+    return true;
+  }
+  return false;
+}
+var no_type_assertion_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow type assertions in TypeScript code.",
+      recommended: "error"
+    },
+    messages: {
+      angleBracketAssertion: "Do not use type assertion",
+      asAssertion: "Do not use `as` operator for type assertion",
+      nonNullAssertion: "Do not use non-null assertion operator"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  createOnce(context) {
+    return {
+      TSTypeAssertion(node) {
+        if (isAllowedTypeAnnotation(node.typeAnnotation)) {
+          return;
+        }
+        context.report({ node, messageId: "angleBracketAssertion" });
+      },
+      TSAsExpression(node) {
+        if (isAllowedTypeAnnotation(node.typeAnnotation)) {
+          return;
+        }
+        context.report({ node, messageId: "asAssertion" });
+      },
+      TSNonNullExpression(node) {
+        context.report({ node, messageId: "nonNullAssertion" });
+      }
+    };
+  }
+};
+
+// packages/plugin-no-type-assertion/src/index.ts
+var plugin = eslintCompatPlugin({
+  meta: { name: "oxlint-plugin-ts-no-assert" },
+  rules: {
+    "no-type-assertion": no_type_assertion_default
+  },
+  configs: {
+    recommended: {
+      rules: {
+        "no-type-assertion/no-type-assertion": "error"
+      }
+    }
+  }
+});
+var src_default = plugin;
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "oxlint-plugin-ts-no-assert",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Disallow TypeScript type assertions (as, angle-bracket, non-null !) — ported from eslint-plugin-no-type-assertion 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",
+    "typescript",
+    "type-assertion",
+    "non-null-assertion",
+    "lint"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/takinprofit/biome-plugins"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}