@timmo001/oxlint-rules 0.1.4 → 0.2.1

package/skills/release-oxlint-rules/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: release-oxlint-rules
+description: >-
+  Create and publish a major, minor, or patch release of
+  @timmo001/oxlint-rules. Use when asked to create, cut, prepare, or publish an
+  oxlint-rules release, including its version bump and npm and JSR publication.
+---
+
+# Release Oxlint Rules
+
+1. Find a writable checkout whose Git remote is
+   `timmo001/oxlint-rules`. Read its `AGENTS.md`, package metadata, release
+   workflow, latest tags, and changes since the latest release. Stop if the
+   worktree contains unrelated changes or the local branch is behind its
+   remote.
+2. Confirm `package.json` and `jsr.json` have the same current version and that
+   its release exists. Resolve the next version from the requested major,
+   minor, patch, or exact version. Ask only when the release level is missing.
+   Do not add a `v` prefix when the repository's existing tags omit it.
+3. Update the version in `package.json` and `jsr.json`. Before committing, run
+   `mise run check`, `mise run build`, `npm pack --dry-run`, and
+   `bunx jsr@0.14.3 publish --dry-run --allow-dirty`. The dirty-tree flag is
+   required because the intended version bump is not committed yet.
+4. Treat a direct request to create or publish the release as authorisation for
+   its version commit, push, and GitHub release. Follow the active environment's
+   guarded commit and push workflow, committing only the release metadata with
+   `Release Oxlint rules <version>`. A request to prepare or plan a release does
+   not authorise publication.
+5. Resolve the target only after the push with `git rev-parse HEAD`. Pass the
+   resulting full 40-character SHA as the `--target` value when running
+   `gh release create`. Never pass an abbreviated SHA as `target_commitish`.
+6. Create the release before resolving workflow targets because publication is
+   triggered by the `release.published` event. Watch only the release commit's
+   exact workflow runs and require both `Publish to npm` and `Publish to JSR` to
+   succeed.
+7. Report the release URL, version commit, validation results, and npm and JSR
+   publication conclusions. Do not report the release as complete while either
+   publication job is pending or failed.

package/src/generic/index.ts

@@ -0,0 +1,12 @@
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+import { preferEventParameterTypeRule } from "./rules/prefer-event-parameter-type.ts";
+
+const timmoPlugin = eslintCompatPlugin({
+  meta: { name: "timmo" },
+  rules: {
+    "prefer-event-parameter-type": preferEventParameterTypeRule,
+  },
+});
+
+export default timmoPlugin;

package/src/generic/rules/prefer-event-parameter-type.ts

@@ -0,0 +1,83 @@
+import { defineRule } from "@oxlint/plugins";
+
+import type { ESTree } from "@oxlint/plugins";
+
+type FunctionNode = ESTree.Function | ESTree.ArrowFunctionExpression;
+type TypeAssertion = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
+
+function nearestEnclosingFunction(node: ESTree.Node): FunctionNode | null {
+  let current: ESTree.Node | null = node.parent;
+  while (current) {
+    if (
+      current.type === "FunctionDeclaration" ||
+      current.type === "FunctionExpression" ||
+      current.type === "ArrowFunctionExpression"
+    ) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+function assertedEventParameter(node: TypeAssertion): {
+  readonly parameter: string;
+  readonly property: "currentTarget" | "target";
+} | null {
+  const expression = node.expression;
+  if (
+    expression.type !== "MemberExpression" ||
+    expression.computed ||
+    expression.object.type !== "Identifier" ||
+    expression.property.type !== "Identifier" ||
+    (expression.property.name !== "currentTarget" &&
+      expression.property.name !== "target")
+  ) {
+    return null;
+  }
+  const parameterName = expression.object.name;
+  const property = expression.property.name;
+  const owner = nearestEnclosingFunction(node);
+  if (
+    !owner?.params.some(
+      (parameter) =>
+        parameter.type === "Identifier" && parameter.name === parameterName,
+    )
+  ) {
+    return null;
+  }
+  return {
+    parameter: parameterName,
+    property,
+  };
+}
+
+/** Prefer expressing an event target type in its handler parameter signature. */
+export const preferEventParameterTypeRule = defineRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Prefer typing event target properties in the handler parameter instead of asserting them at use sites.",
+    },
+    messages: {
+      typeEventParameter:
+        "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site.",
+    },
+  },
+  create(context) {
+    const checkAssertion = (node: TypeAssertion) => {
+      const eventParameter = assertedEventParameter(node);
+      if (!eventParameter) return;
+      context.report({
+        node,
+        messageId: "typeEventParameter",
+        data: eventParameter,
+      });
+    };
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion,
+    };
+  },
+});