@oxlint/plugins 1.43.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-present VoidZero Inc. & Contributors
+Copyright (c) 2023 Boshen
+
+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,95 @@
+# @oxlint/plugins
+
+Plugin utilities for [Oxlint](https://oxc.rs/docs/guide/usage/linter/js-plugins).
+
+This package provides optional functions to assist in creating Oxlint JS plugins and rules.
+
+## Installation
+
+```bash
+npm install @oxlint/plugins
+```
+
+## Usage
+
+### Define functions
+
+Use `definePlugin` and `defineRule` if authoring your plugin in TypeScript for type safety.
+
+```typescript
+import { definePlugin, defineRule } from "@oxlint/plugins";
+
+const rule = defineRule({
+  create(context) {
+    return {
+      Program(node) {
+        // Rule logic here
+      },
+    };
+  },
+});
+
+export default definePlugin({
+  meta: { name: "oxlint-plugin-amazing" },
+  rules: { amazing: rule },
+});
+```
+
+### Types
+
+This package also includes types for plugins and rules.
+
+```typescript
+import type { Context, Rule, ESTree } from "@oxlint/plugins";
+
+const rule: Rule = {
+  create(context: Context) {
+    return {
+      Program(node: ESTree.Program) {
+        // Rule logic here
+      },
+    };
+  },
+};
+```
+
+### ESLint compatibility
+
+If your plugin uses Oxlint's [alternative `createOnce` API](https://oxc.rs/docs/guide/usage/linter/js-plugins#alternative-api),
+use `eslintCompatPlugin` to convert the plugin so it will also work with ESLint.
+
+```typescript
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+const rule = {
+  createOnce(context) {
+    return {
+      Program(node) {
+        // Rule logic here
+      },
+    };
+  },
+};
+
+export default eslintCompatPlugin({
+  meta: { name: "oxlint-plugin-amazing" },
+  rules: { amazing: rule },
+});
+```
+
+## Node.js version
+
+This package requires Node.js 12.22.0+, 14.17.0+, 16.0.0+, or later.
+This matches the minimum Node.js version required by ESLint 8.
+
+This package provides both ESM and CommonJS entry points.
+
+So a plugin which depends on `@oxlint/plugins` can be:
+
+- Used with any version of Oxlint.
+- Used with ESLint 8+.
+- Published as either ESM or CommonJS.
+
+## Docs
+
+For full documentation, see [Oxlint JS Plugins docs](https://oxc.rs/docs/guide/usage/linter/js-plugins).

package/index.cjs

@@ -0,0 +1,110 @@
+function definePlugin(plugin) {
+	return plugin;
+}
+function defineRule(rule) {
+	return rule;
+}
+const 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() === !1 ? EMPTY_VISITOR : visitor);
+}
+const 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: !0,
+			configurable: !0
+		},
+		options: {
+			value: null,
+			enumerable: !0,
+			configurable: !0
+		},
+		report: {
+			value: null,
+			enumerable: !0,
+			configurable: !0
+		}
+	}), { before: beforeHook, after: afterHook, ...visitor } = createOnce.call(rule, context);
+	if (beforeHook === void 0) 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 key in visitor) {
+			if (!Object.hasOwn(visitor, key) || !key.endsWith(":exit")) continue;
+			let end = key.length - 5, count = 0;
+			for (let i = 0; i < end; i++) {
+				let c = key.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
+	};
+}
+exports.definePlugin = definePlugin, exports.defineRule = defineRule, exports.eslintCompatPlugin = eslintCompatPlugin;