@nekoyasuii/config 0.1.3 → 0.1.5

package/dist/tools/oxlint/config/react/index.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Every non-nursery react, react-perf, and jsx-a11y rule oxlint implements
+ * is listed explicitly (mirroring the core config's philosophy), with
+ * decisions matching the ESLint react preset
+ */
 export declare const reactConfig: {
     plugins: ("jsx-a11y" | "react" | "react-perf")[];
     rules: {
@@ -37,14 +42,31 @@ export declare const reactConfig: {
         "jsx-a11y/role-supports-aria-props": "error";
         "jsx-a11y/scope": "error";
         "jsx-a11y/tabindex-no-positive": "error";
+        /**
+         * Inline JSX/object/array/function props are idiomatic modern React;
+         * the react-doctor rules (opt-in js-plugins preset) cover the cases that
+         * actually hurt
+         */
         "react-perf/jsx-no-jsx-as-prop": "off";
         "react-perf/jsx-no-new-array-as-prop": "off";
         "react-perf/jsx-no-new-function-as-prop": "off";
         "react-perf/jsx-no-new-object-as-prop": "off";
+        /** "react/button-has-type": "error", */
         "react/capitalized-calls": "error";
+        /**
+         * "react/checked-requires-onchange-or-readonly": "error",
+         * "react/display-name": "error",
+         */
         "react/error-boundaries": "error";
         "react/exhaustive-deps": "error";
         "react/exhaustive-effect-dependencies": "error";
+        /**
+         * "react/forbid-component-props": "off",
+         * "react/forbid-dom-props": "error",
+         * "react/forbid-elements": "error",
+         * forwardRef is deprecated in React 19; react-doctor/no-react19-deprecated-apis
+         * (opt-in js-plugins preset) covers it
+         */
         "react/forward-ref-uses-ref": "off";
         "react/function-component-definition": ["error", {
             namedComponents: "arrow-function";
@@ -57,33 +79,53 @@ export declare const reactConfig: {
         "react/immutability": "error";
         "react/incompatible-library": "error";
         "react/invariant": "error";
+        /** "react/jsx-boolean-value": "off", */
         "react/jsx-curly-brace-presence": "error";
+        /** "react/jsx-filename-extension": "off", */
         "react/jsx-fragments": "error";
         "react/jsx-key": "error";
+        /** "react/jsx-max-depth": "off", */
         "react/jsx-no-comment-textnodes": "error";
         "react/jsx-no-constructed-context-values": "error";
         "react/jsx-no-duplicate-props": "error";
+        /**
+         * "react/jsx-no-literals": "off",
+         * "react/jsx-no-script-url": "error",
+         */
         "react/jsx-no-target-blank": "error";
         "react/jsx-no-undef": "error";
         "react/jsx-no-useless-fragment": "error";
+        /** "react/jsx-pascal-case": "error", */
         "react/jsx-props-no-spread-multi": "error";
+        /** "react/jsx-props-no-spreading": "off", */
         "react/memo-dependencies": "error";
+        /**
+         * Off in the ESLint preset; react-doctor/no-random-key (opt-in js-plugins
+         * preset) covers the dangerous cases.
+         * "react/no-array-index-key": "off",
+         */
         "react/no-children-prop": "error";
         "react/no-clone-element": "error";
+        /** "react/no-danger": "error", */
         "react/no-danger-with-children": "error";
         "react/no-deriving-state-in-effects": "error";
+        /** "react/no-did-mount-set-state": "error", */
         "react/no-did-update-set-state": "error";
         "react/no-direct-mutation-state": "error";
         "react/no-find-dom-node": "error";
         "react/no-is-mounted": "error";
+        /** "react/no-multi-comp": "off", */
         "react/no-namespace": "error";
+        /** "react/no-object-type-as-default-prop": "error", */
         "react/no-react-children": "error";
+        /** "react/no-redundant-should-component-update": "error", */
         "react/no-render-return-value": "error";
         "react/no-set-state": "error";
         "react/no-string-refs": "error";
         "react/no-this-in-sfc": "error";
         "react/no-unescaped-entities": "error";
         "react/no-unknown-property": "off";
+        /** "react/no-unsafe": "error", */
         "react/no-unstable-nested-components": "error";
         "react/no-will-update-set-state": "error";
         "react/prefer-es6-class": "error";
@@ -106,10 +148,15 @@ export declare const reactConfig: {
         "react/use-memo": "error";
         "react/void-dom-elements-no-children": "error";
         "react/void-use-memo": "error";
+        /**
+         * Prop forwarding (`onClick={action.onClick}`) is not a handler-naming
+         * problem, and react-doctor's own rules cover the cases that hurt
+         */
         "react/jsx-handler-names": "off";
         "react/only-export-components": ["warn", {
             allowConstantExport: true;
         }];
+        /** overrides */
         "react/button-has-type": ["off"];
         "react/checked-requires-onchange-or-readonly": ["off"];
         "react/display-name": ["off"];

package/dist/tools/oxlint/config/tanstack/index.d.ts

@@ -2,6 +2,11 @@ export declare const tanstackConfig: {
     overrides: ({
         files: string[];
         rules: {
+            /**
+             * Route option types are order-sensitive (`head`/`component` infer
+             * `loaderData` from properties declared before them), so alphabetical
+             * ordering conflicts with tanstack-start-route-property-order
+             */
             "sort-keys": "off";
             "unicorn/filename-case": "off";
             "unicorn/no-abusive-eslint-disable"?: undefined;
@@ -9,6 +14,11 @@ export declare const tanstackConfig: {
     } | {
         files: string[];
         rules: {
+            /**
+             * Route option types are order-sensitive (`head`/`component` infer
+             * `loaderData` from properties declared before them), so alphabetical
+             * ordering conflicts with tanstack-start-route-property-order
+             */
             "sort-keys"?: undefined;
             "unicorn/filename-case": "off";
             "unicorn/no-abusive-eslint-disable": "off";

package/dist/tools/oxlint/config/tanstack/js-plugins/index.d.ts

@@ -1,3 +1,21 @@
+/**
+ * React Doctor's TanStack Query/Router/Start rules. These live outside the
+ * base js-plugins preset because some of them fire on generic JSX (e.g. plain
+ * <a> elements) and recommend TanStack replacements, which is pure noise in
+ * non-TanStack projects. Extend this alongside js-plugins in TanStack apps:
+ *
+ * import { defineConfig } from "oxlint";
+ * import core from "ultracite/oxlint/core";
+ * import tanstack from "ultracite/oxlint/tanstack";
+ * import jsPlugins from "ultracite/oxlint/js-plugins";
+ * import tanstackJsPlugins from "ultracite/oxlint/tanstack/js-plugins";
+ *
+ * export default defineConfig({
+ * extends: [core, tanstack, jsPlugins, tanstackJsPlugins],
+ * ignorePatterns: core.ignorePatterns,
+ * jsPlugins: jsPlugins.jsPlugins,
+ * });
+ */
 declare const _default: {
     jsPlugins: {
         name: string;

package/dist/tools/oxlint/rules/index.js

@@ -49,6 +49,261 @@ var FILE_CONTEXT = Object.freeze({
   }
 });
 
+// tools/oxlint/rules/canonical-header-names/index.ts
+var HeaderWordCasingExceptions = {
+  ct: "CT",
+  dpop: "DPoP",
+  etag: "ETag",
+  te: "TE",
+  www: "WWW",
+  x: "X",
+  xss: "XSS"
+};
+var headerNamePattern = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u;
+var headerMethods = new Set(["append", "delete", "get", "has", "set"]);
+function canonicalHeaderName(name) {
+  return name.toLowerCase().split("-").map((word) => HeaderWordCasingExceptions[word] || word.charAt(0).toUpperCase() + word.slice(1)).join("-");
+}
+function isStringLiteral(node) {
+  return node.type === "Literal" && typeof node.value === "string";
+}
+function isStaticMemberExpression(node) {
+  return node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier";
+}
+function isIdentifierReference(node) {
+  return node.type === "Identifier";
+}
+function isHeadersIdentifierName(name) {
+  return name === "headers" || name.endsWith("Headers");
+}
+function isNewHeadersExpression(node) {
+  return node.type === "NewExpression" && isIdentifierReference(node.callee) && node.callee.name === "Headers";
+}
+function isLikelyHeadersReceiver(node) {
+  if (isIdentifierReference(node)) {
+    return isHeadersIdentifierName(node.name);
+  }
+  if (isStaticMemberExpression(node)) {
+    return node.property.name === "headers";
+  }
+  return isNewHeadersExpression(node);
+}
+function quoteLike(raw, value) {
+  const quote = raw?.startsWith('"') ? '"' : "'";
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll(quote, `\\${quote}`);
+  return `${quote}${escaped}${quote}`;
+}
+function getStaticPropertyName(node) {
+  if (node.computed) {
+    return null;
+  }
+  if (node.key.type === "Identifier") {
+    return node.key.name;
+  }
+  if (node.key.type === "Literal" && typeof node.key.value === "string") {
+    return node.key.value;
+  }
+  return null;
+}
+function getHeaderPropertyKeyFixText(node, canonicalName) {
+  if (node.type === "Literal") {
+    return quoteLike(node.raw, canonicalName);
+  }
+  return canonicalName;
+}
+function isHeaderPropertyKey(node) {
+  return node.type === "Identifier" || node.type === "Literal" && typeof node.value === "string";
+}
+function reportHeaderName(context, node, name) {
+  if (!headerNamePattern.test(name)) {
+    return;
+  }
+  const canonicalName = canonicalHeaderName(name);
+  if (name === canonicalName) {
+    return;
+  }
+  context.report({
+    node,
+    message: `Use canonical HTTP header name '${canonicalName}'.`,
+    fix(fixer) {
+      return fixer.replaceText(node, getHeaderPropertyKeyFixText(node, canonicalName));
+    }
+  });
+}
+function checkHeadersInitObject(context, node) {
+  for (const property of node.properties) {
+    if (property.type !== "Property") {
+      continue;
+    }
+    const headerName = getStaticPropertyName(property);
+    if (headerName === null) {
+      continue;
+    }
+    if (!isHeaderPropertyKey(property.key)) {
+      continue;
+    }
+    reportHeaderName(context, property.key, headerName);
+  }
+}
+function isHeadersInitPropertyValue(node) {
+  const { parent } = node;
+  if (parent.type !== "Property" || parent.value !== node) {
+    return false;
+  }
+  return getStaticPropertyName(parent) === "headers";
+}
+var canonicalHeaderNames = defineRule({
+  meta: {
+    type: "suggestion",
+    fixable: "code"
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isStaticMemberExpression(node.callee)) {
+          return;
+        }
+        const methodName = node.callee.property.name;
+        if (!headerMethods.has(methodName)) {
+          return;
+        }
+        if (!isLikelyHeadersReceiver(node.callee.object)) {
+          return;
+        }
+        const [headerName] = node.arguments;
+        if (!headerName || !isStringLiteral(headerName)) {
+          return;
+        }
+        reportHeaderName(context, headerName, headerName.value);
+      },
+      NewExpression(node) {
+        if (!isNewHeadersExpression(node)) {
+          return;
+        }
+        const [headersInit] = node.arguments;
+        if (headersInit?.type !== "ObjectExpression") {
+          return;
+        }
+        checkHeadersInitObject(context, headersInit);
+      },
+      ObjectExpression(node) {
+        if (!isHeadersInitPropertyValue(node)) {
+          return;
+        }
+        checkHeadersInitObject(context, node);
+      }
+    };
+  }
+});
+
+// tools/oxlint/rules/interface-pascal-case/index.ts
+var pascalCasePattern = /^[A-Z][A-Za-z0-9]*$/u;
+function toPascalCase(name) {
+  return name.replaceAll(/(?<lower>[a-z0-9])(?<upper>[A-Z])/gu, "$<lower> $<upper>").split(/[\s_-]+/u).filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function isExported(node) {
+  return node.parent?.type === "ExportNamedDeclaration";
+}
+function renameFix(context, node, newName) {
+  if (isExported(node))
+    return;
+  try {
+    const [variable] = context.sourceCode.getDeclaredVariables(node);
+    if (!variable)
+      return;
+    return (fixer) => [
+      ...variable.defs.map((definition) => fixer.replaceText(definition.name, newName)),
+      ...variable.references.map((reference) => fixer.replaceText(reference.identifier, newName))
+    ];
+  } catch {
+    return;
+  }
+}
+var interfacePascalCase = defineRule({
+  meta: {
+    fixable: "code",
+    messages: {
+      interface: "Unexpected interface name {{name}}. Use {{newName}} instead",
+      exported: "Unexpected interface name {{name}}. Use {{newName}} instead. It is exported, so rename its usages in every file manually; no autofix is available",
+      pascalCase: "Interface name {{name}} must use PascalCase"
+    },
+    type: "suggestion"
+  },
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        const { name } = node.id;
+        if (pascalCasePattern.test(name)) {
+          return;
+        }
+        const newName = toPascalCase(name);
+        const renameable = newName !== name && pascalCasePattern.test(newName);
+        const exported = renameable && isExported(node);
+        const fixable = renameable && !exported;
+        let messageId = "pascalCase";
+        if (fixable) {
+          messageId = "interface";
+        } else if (exported) {
+          messageId = "exported";
+        }
+        context.report({
+          data: { name, newName },
+          fix: fixable ? renameFix(context, node, newName) : undefined,
+          messageId,
+          node: node.id
+        });
+      }
+    };
+  }
+});
+
+// tools/oxlint/rules/no-ts-accessibility/index.ts
+var noTypescriptAccessibility = defineRule({
+  meta: {
+    type: "problem"
+  },
+  create(context) {
+    return {
+      PropertyDefinition(node) {
+        if (node.accessibility == null) {
+          return;
+        }
+        context.report({
+          node,
+          message: "Use native class fields: omit 'public' and use '#private' for private state."
+        });
+      },
+      MethodDefinition(node) {
+        if (node.accessibility == null) {
+          return;
+        }
+        if (node.kind !== "constructor") {
+          context.report({
+            node,
+            message: "Use native methods: omit 'public'; for private behavior use '#private' fields/methods."
+          });
+          return;
+        }
+        if (node.accessibility === "public") {
+          context.report({
+            node,
+            message: "Omit 'public' on constructors; it's the default."
+          });
+        }
+      },
+      TSParameterProperty(node) {
+        if (node.accessibility == null) {
+          return;
+        }
+        context.report({
+          node,
+          message: "Avoid TS parameter properties; declare fields explicitly and use '#private' when needed."
+        });
+      }
+    };
+  }
+});
+
 // tools/oxlint/rules/prefer-alias/rule.ts
 import fs2 from "node:fs";
 import path2 from "node:path";
@@ -474,7 +729,12 @@ var preferAlias = defineRule({
 // tools/oxlint/rules/index.ts
 var plugin = definePlugin({
   meta: { name: "lazuee" },
-  rules: { "prefer-alias": preferAlias }
+  rules: {
+    "prefer-alias": preferAlias,
+    "no-ts-accessibility": noTypescriptAccessibility,
+    "interface-pascal-case": interfacePascalCase,
+    "canonical-header-names": canonicalHeaderNames
+  }
 });
 var rules_default = plugin;
 export {

package/dist/tools/shared/tsconfig-aliases.d.ts

@@ -1,11 +1,12 @@
 export interface AliasConfig {
+    /** Glob patterns for path aliases, mapped to their replacement targets */
     aliasPatterns: Record<string, string[]>;
-    /** Directory that `paths` entries are resolved against. */
+    /** Directory that `paths` entries are resolved against */
     basePath: string;
 }
 /**
  * Removes `//` and block comments plus trailing commas, skipping the contents
- * of string literals so values like "http://localhost" survive.
+ * of string literals so values like "http://localhost" survive
  */
 export declare function stripJsonComments(source: string): string;
 export declare function loadTsConfigAliases(cwd: string): AliasConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nekoyasuii/config",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Shared TypeScript, Oxlint, and Oxfmt configs for my projects.",
   "files": [
     "dist",
@@ -23,6 +23,11 @@
       "import": "./dist/tools/oxlint/config/anti-slop/index.js",
       "default": "./dist/tools/oxlint/config/anti-slop/index.js"
     },
+    "./oxlint/no-comment-slop": {
+      "types": "./dist/tools/oxlint/config/no-comment-slop/index.d.ts",
+      "import": "./dist/tools/oxlint/config/no-comment-slop/index.js",
+      "default": "./dist/tools/oxlint/config/no-comment-slop/index.js"
+    },
     "./oxlint/rules": {
       "types": "./dist/tools/oxlint/rules/index.d.ts",
       "import": "./dist/tools/oxlint/rules/index.js",