@blogic-cz/oxc-config 1.0.0 → 1.1.0

package/.oxlintrc.ts.json

@@ -1,5 +1,9 @@
 {
   "$schema": "https://raw.githubusercontent.com/niconiconainu/oxc/HEAD/npm/oxc-types/src/generated/schema/oxlintrc.json",
+  "jsPlugins": [
+    "./plugins/enforce-props-type-name.js",
+    "./plugins/max-file-lines.js"
+  ],
   "plugins": [
     "import",
     "node",
@@ -50,9 +54,27 @@
     "unicorn/prefer-set-has": "error",
     "unicorn/require-module-specifiers": "off",
     "unicorn/throw-new-error": "error",
+    "node/handle-callback-err": "error",
+    "typescript/no-unnecessary-type-conversion": "error",
     "vitest/no-import-node-test": "error",
+    "vitest/prefer-strict-boolean-matchers": "error",
     "oxc/no-map-spread": "error",
-    "promise/always-return": "error"
+    "promise/always-return": "error",
+    "file-quality/kebab-case-filename": "error",
+    "file-quality/max-file-lines": [
+      "off",
+      {
+        "maxLines": 500,
+        "extensions": [".tsx"]
+      }
+    ],
+    "file-quality/no-barrel-files": "error",
+    "naming/enforce-props-type-name": "error",
+    "naming/no-default-parameter-values": "error",
+    "naming/no-console-in-server": "error",
+    "naming/no-dynamic-type-import": "error",
+    "naming/no-server-logger-in-client": "error",
+    "naming/no-undefined-parameter-union": "error"
   },
   "overrides": [
     {
@@ -90,6 +112,9 @@
         "eslint/no-shadow": "off",
         "eslint/require-await": "off",
         "import/no-relative-parent-imports": "off",
+        "naming/enforce-props-type-name": "off",
+        "naming/no-default-parameter-values": "off",
+        "naming/no-undefined-parameter-union": "off",
         "typescript/no-unsafe-type-assertion": "off",
         "unicorn/no-array-sort": "off"
       }
@@ -102,6 +127,7 @@
       "rules": {
         "eslint/no-new": "off",
         "import/no-relative-parent-imports": "off",
+        "naming/no-default-parameter-values": "off",
         "typescript/consistent-type-definitions": "off",
         "typescript/no-import-type-side-effects": "off",
         "typescript/no-non-null-assertion": "off"
@@ -121,7 +147,8 @@
         "packages/logger/src/**"
       ],
       "rules": {
-        "eslint/require-await": "off"
+        "eslint/require-await": "off",
+        "naming/no-default-parameter-values": "off"
       }
     }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/oxc-config",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Shared oxlint and oxfmt configs for blogic projects — layered TypeScript, React, and formatter presets",
   "keywords": [
     "oxlint",
@@ -24,9 +24,15 @@
     ".oxlintrc.ts.json",
     ".oxlintrc.ts-react.json",
     ".oxfmtrc.base.jsonc",
+    "plugins/*.js",
+    "plugins/*.ts",
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "bun build plugins/enforce-props-type-name.ts --outdir plugins --outfile enforce-props-type-name.js && bun build plugins/max-file-lines.ts --outdir plugins --outfile max-file-lines.js",
+    "prepublishOnly": "bun run build"
+  },
   "publishConfig": {
     "access": "public"
   }

package/plugins/enforce-props-type-name.js

@@ -0,0 +1,136 @@
+// plugins/enforce-props-type-name.ts
+var isFunctionNode = (type) => type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression" || type === "TSDeclareFunction";
+var plugin = {
+  meta: {
+    name: "naming"
+  },
+  rules: {
+    "enforce-props-type-name": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          TSTypeAliasDeclaration(node) {
+            if (!context.filename.endsWith(".tsx")) {
+              return;
+            }
+            const name = node.id.name;
+            if (name.endsWith("Props") && name !== "Props") {
+              context.report({
+                message: `Props type must be named "Props", not "${name}". Use \`type Props = { ... }\` instead.`,
+                node: node.id
+              });
+            }
+          }
+        };
+      }
+    },
+    "no-dynamic-type-import": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          TSImportType(node) {
+            context.report({
+              message: 'Use regular `import type` instead of dynamic `import("...")` type syntax.',
+              node
+            });
+          }
+        };
+      }
+    },
+    "no-server-logger-in-client": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          ImportDeclaration(node) {
+            const source = node.source.value;
+            if ((source.endsWith("/logger") || source === "pino") && context.filename.endsWith(".tsx")) {
+              context.report({
+                message: `Do not import "${source}" in client-side (.tsx) files. Use console.log/console.error instead.`,
+                node
+              });
+            }
+          }
+        };
+      }
+    },
+    "no-console-in-server": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          MemberExpression(node) {
+            const filename = context.filename;
+            const isServerFile = filename.endsWith(".ts") && !filename.endsWith(".tsx");
+            const isWebAppServer = filename.includes("apps/web-app/src/");
+            const isExcluded = filename.includes(".test.ts") || filename.includes("/jobs/") || filename.includes("/scripts/");
+            if (isServerFile && isWebAppServer && !isExcluded && node.object.type === "Identifier" && node.object.name === "console") {
+              context.report({
+                message: "Do not use console.* in server-side code. Use the project logger package instead.",
+                node
+              });
+            }
+          }
+        };
+      }
+    },
+    "no-default-parameter-values": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          AssignmentPattern(node) {
+            const parentType = node.parent.type;
+            const isFunctionParamDefault = parentType === "FunctionDeclaration" || parentType === "FunctionExpression" || parentType === "ArrowFunctionExpression" || parentType === "TSParameterProperty";
+            if (!isFunctionParamDefault) {
+              return;
+            }
+            context.report({
+              message: "Default parameter values are not allowed. Require the caller to pass the value explicitly.",
+              node
+            });
+          }
+        };
+      }
+    },
+    "no-undefined-parameter-union": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          TSUndefinedKeyword(node) {
+            if (node.parent.type !== "TSUnionType") {
+              return;
+            }
+            if (node.parent.parent.type !== "TSTypeAnnotation") {
+              return;
+            }
+            const annotationTarget = node.parent.parent.parent;
+            const parentType = annotationTarget.parent.type;
+            const isDirectFunctionParam = parentType && isFunctionNode(parentType);
+            const isTsParameterProperty = annotationTarget.type === "Identifier" && parentType === "TSParameterProperty" && annotationTarget.parent.parent.type === "FunctionExpression" && annotationTarget.parent.parent.parent.type === "MethodDefinition";
+            if (!isDirectFunctionParam && !isTsParameterProperty) {
+              return;
+            }
+            context.report({
+              message: "Avoid `| undefined` in parameter types. Use explicit `| null` (or an optional parameter when intended).",
+              node
+            });
+          }
+        };
+      }
+    }
+  }
+};
+var enforce_props_type_name_default = plugin;
+export {
+  enforce_props_type_name_default as default
+};

package/plugins/enforce-props-type-name.ts

@@ -0,0 +1,192 @@
+import type { Plugin } from "#oxlint/plugins";
+
+const isFunctionNode = (type: string): boolean =>
+  type === "FunctionDeclaration" ||
+  type === "FunctionExpression" ||
+  type === "ArrowFunctionExpression" ||
+  type === "TSDeclareFunction";
+
+const plugin: Plugin = {
+  meta: {
+    name: "naming",
+  },
+  rules: {
+    "enforce-props-type-name": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          TSTypeAliasDeclaration(node) {
+            if (!context.filename.endsWith(".tsx")) {
+              return;
+            }
+
+            const name = node.id.name;
+            if (
+              name.endsWith("Props") &&
+              name !== "Props"
+            ) {
+              context.report({
+                message: `Props type must be named "Props", not "${name}". Use \`type Props = { ... }\` instead.`,
+                node: node.id,
+              });
+            }
+          },
+        };
+      },
+    },
+    "no-dynamic-type-import": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          TSImportType(node) {
+            context.report({
+              message:
+                'Use regular `import type` instead of dynamic `import("...")` type syntax.',
+              node,
+            });
+          },
+        };
+      },
+    },
+    "no-server-logger-in-client": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          ImportDeclaration(node) {
+            const source = node.source.value;
+            if (
+              (source.endsWith("/logger") ||
+                source === "pino") &&
+              context.filename.endsWith(".tsx")
+            ) {
+              context.report({
+                message: `Do not import "${source}" in client-side (.tsx) files. Use console.log/console.error instead.`,
+                node,
+              });
+            }
+          },
+        };
+      },
+    },
+    "no-console-in-server": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          MemberExpression(node) {
+            const filename = context.filename;
+            const isServerFile =
+              filename.endsWith(".ts") &&
+              !filename.endsWith(".tsx");
+            const isWebAppServer = filename.includes(
+              "apps/web-app/src/"
+            );
+            const isExcluded =
+              filename.includes(".test.ts") ||
+              filename.includes("/jobs/") ||
+              filename.includes("/scripts/");
+
+            if (
+              isServerFile &&
+              isWebAppServer &&
+              !isExcluded &&
+              node.object.type === "Identifier" &&
+              node.object.name === "console"
+            ) {
+              context.report({
+                message:
+                  "Do not use console.* in server-side code. Use the project logger package instead.",
+                node,
+              });
+            }
+          },
+        };
+      },
+    },
+    "no-default-parameter-values": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          AssignmentPattern(node) {
+            const parentType = node.parent.type;
+
+            const isFunctionParamDefault =
+              parentType === "FunctionDeclaration" ||
+              parentType === "FunctionExpression" ||
+              parentType === "ArrowFunctionExpression" ||
+              parentType === "TSParameterProperty";
+
+            if (!isFunctionParamDefault) {
+              return;
+            }
+
+            context.report({
+              message:
+                "Default parameter values are not allowed. Require the caller to pass the value explicitly.",
+              node,
+            });
+          },
+        };
+      },
+    },
+    "no-undefined-parameter-union": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          TSUndefinedKeyword(node) {
+            if (node.parent.type !== "TSUnionType") {
+              return;
+            }
+
+            if (
+              node.parent.parent.type !== "TSTypeAnnotation"
+            ) {
+              return;
+            }
+
+            const annotationTarget =
+              node.parent.parent.parent;
+            const parentType = annotationTarget.parent.type;
+
+            const isDirectFunctionParam =
+              parentType && isFunctionNode(parentType);
+
+            const isTsParameterProperty =
+              annotationTarget.type === "Identifier" &&
+              parentType === "TSParameterProperty" &&
+              annotationTarget.parent.parent.type ===
+                "FunctionExpression" &&
+              annotationTarget.parent.parent.parent.type ===
+                "MethodDefinition";
+
+            if (
+              !isDirectFunctionParam &&
+              !isTsParameterProperty
+            ) {
+              return;
+            }
+
+            context.report({
+              message:
+                "Avoid `| undefined` in parameter types. Use explicit `| null` (or an optional parameter when intended).",
+              node,
+            });
+          },
+        };
+      },
+    },
+  },
+};
+
+export default plugin;

package/plugins/max-file-lines.js

@@ -0,0 +1,133 @@
+// plugins/max-file-lines.ts
+function parseOptions(value) {
+  if (typeof value !== "object" || value === null) {
+    return { maxLines: 500, extensions: [".tsx"] };
+  }
+  const maxLines = typeof value.maxLines === "number" ? value.maxLines : 500;
+  const extensions = Array.isArray(value.extensions) ? value.extensions.filter((extension) => typeof extension === "string") : [".tsx"];
+  return {
+    maxLines,
+    extensions: extensions.length > 0 ? extensions : [".tsx"]
+  };
+}
+var plugin = {
+  meta: {
+    name: "file-quality"
+  },
+  rules: {
+    "max-file-lines": {
+      meta: {
+        defaultOptions: [
+          {
+            maxLines: 500,
+            extensions: [".tsx"]
+          }
+        ],
+        schema: [
+          {
+            type: "object",
+            default: {},
+            properties: {
+              maxLines: { type: "number", default: 500 },
+              extensions: {
+                type: "array",
+                items: { type: "string" },
+                default: [".tsx"]
+              }
+            },
+            additionalProperties: false
+          }
+        ]
+      },
+      create(context) {
+        return {
+          Program() {
+            const options = parseOptions(context.options[0]);
+            const { maxLines, extensions } = options;
+            if (!extensions.some((ext) => context.filename.endsWith(ext))) {
+              return;
+            }
+            const lineCount = context.sourceCode.lines.length;
+            if (lineCount <= maxLines) {
+              return;
+            }
+            context.report({
+              message: `File has ${lineCount} lines (max ${maxLines}). Consider splitting into smaller modules.`,
+              node: context.sourceCode.ast
+            });
+          }
+        };
+      }
+    },
+    "no-barrel-files": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          Program(node) {
+            const filename = context.filename;
+            if (!filename.endsWith("/index.ts")) {
+              return;
+            }
+            if (/packages\/[^/]+\/src\//.test(filename)) {
+              return;
+            }
+            const body = node.body;
+            if (body.length === 0) {
+              return;
+            }
+            const isBarrel = body.every((stmt) => stmt.type === "ExportNamedDeclaration" && stmt.source !== null || stmt.type === "ExportAllDeclaration" || stmt.type === "ImportDeclaration");
+            if (isBarrel) {
+              context.report({
+                message: "Barrel files (index.ts with only re-exports) are not allowed. Import directly from source files.",
+                node
+              });
+            }
+          }
+        };
+      }
+    },
+    "kebab-case-filename": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          Program(node) {
+            const filename = context.filename;
+            if (filename.includes("node_modules") || filename.endsWith(".d.ts")) {
+              return;
+            }
+            const parts = filename.split("/");
+            const basename = parts.at(-1);
+            if (!basename) {
+              return;
+            }
+            if (basename.includes("$") || basename.includes("[") || basename.includes("]")) {
+              return;
+            }
+            const nameWithoutExt = basename.replace(/\.(test|e2e|server|client|config)\.(ts|tsx|js|jsx|mjs|cjs)$/, "").replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+            if (nameWithoutExt === "") {
+              return;
+            }
+            if (nameWithoutExt === "routeTree.gen" || nameWithoutExt === "Dockerfile" || nameWithoutExt.startsWith("__") || nameWithoutExt.endsWith(".gen") || nameWithoutExt === "vite-env") {
+              return;
+            }
+            const kebabRegex = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+            if (!kebabRegex.test(nameWithoutExt)) {
+              context.report({
+                message: `Filename "${basename}" must use kebab-case (e.g., "my-component.tsx").`,
+                node
+              });
+            }
+          }
+        };
+      }
+    }
+  }
+};
+var max_file_lines_default = plugin;
+export {
+  max_file_lines_default as default
+};

package/plugins/max-file-lines.ts

@@ -0,0 +1,201 @@
+import type { Plugin } from "#oxlint/plugins";
+
+function parseOptions(value: unknown): {
+  maxLines: number;
+  extensions: string[];
+} {
+  if (typeof value !== "object" || value === null) {
+    return { maxLines: 500, extensions: [".tsx"] };
+  }
+
+  const maxLines =
+    typeof value.maxLines === "number"
+      ? value.maxLines
+      : 500;
+  const extensions = Array.isArray(value.extensions)
+    ? value.extensions.filter(
+        (extension) => typeof extension === "string"
+      )
+    : [".tsx"];
+
+  return {
+    maxLines,
+    extensions:
+      extensions.length > 0 ? extensions : [".tsx"],
+  };
+}
+
+const plugin: Plugin = {
+  meta: {
+    name: "file-quality",
+  },
+  rules: {
+    "max-file-lines": {
+      meta: {
+        defaultOptions: [
+          {
+            maxLines: 500,
+            extensions: [".tsx"],
+          },
+        ],
+        schema: [
+          {
+            type: "object",
+            default: {},
+            properties: {
+              maxLines: { type: "number", default: 500 },
+              extensions: {
+                type: "array",
+                items: { type: "string" },
+                default: [".tsx"],
+              },
+            },
+            additionalProperties: false,
+          },
+        ],
+      },
+      create(context) {
+        return {
+          Program() {
+            const options = parseOptions(
+              context.options[0]
+            );
+            const { maxLines, extensions } = options;
+
+            if (
+              !extensions.some((ext) =>
+                context.filename.endsWith(ext)
+              )
+            ) {
+              return;
+            }
+
+            const lineCount =
+              context.sourceCode.lines.length;
+            if (lineCount <= maxLines) {
+              return;
+            }
+
+            context.report({
+              message: `File has ${lineCount} lines (max ${maxLines}). Consider splitting into smaller modules.`,
+              node: context.sourceCode.ast,
+            });
+          },
+        };
+      },
+    },
+    "no-barrel-files": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          Program(node) {
+            const filename = context.filename;
+
+            // Only check index.ts files (not .tsx — route files are OK)
+            if (!filename.endsWith("/index.ts")) {
+              return;
+            }
+
+            // Exception: any index.ts inside packages/ (root and sub-path entry points)
+            if (/packages\/[^/]+\/src\//.test(filename)) {
+              return;
+            }
+
+            const body = node.body;
+            if (body.length === 0) {
+              return;
+            }
+
+            const isBarrel = body.every(
+              (stmt) =>
+                (stmt.type === "ExportNamedDeclaration" &&
+                  stmt.source !== null) ||
+                stmt.type === "ExportAllDeclaration" ||
+                stmt.type === "ImportDeclaration"
+            );
+
+            if (isBarrel) {
+              context.report({
+                message:
+                  "Barrel files (index.ts with only re-exports) are not allowed. Import directly from source files.",
+                node,
+              });
+            }
+          },
+        };
+      },
+    },
+    "kebab-case-filename": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          Program(node) {
+            const filename = context.filename;
+
+            // Skip node_modules and .d.ts files
+            if (
+              filename.includes("node_modules") ||
+              filename.endsWith(".d.ts")
+            ) {
+              return;
+            }
+
+            const parts = filename.split("/");
+            const basename = parts.at(-1);
+            if (!basename) {
+              return;
+            }
+
+            // Skip TanStack Router dynamic segments ($param, $, [param])
+            if (
+              basename.includes("$") ||
+              basename.includes("[") ||
+              basename.includes("]")
+            ) {
+              return;
+            }
+
+            // Strip compound extensions first, then simple
+            const nameWithoutExt = basename
+              .replace(
+                /\.(test|e2e|server|client|config)\.(ts|tsx|js|jsx|mjs|cjs)$/,
+                ""
+              )
+              .replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "");
+
+            // Skip empty names (e.g., just an extension)
+            if (nameWithoutExt === "") {
+              return;
+            }
+
+            // Skip known special files
+            if (
+              nameWithoutExt === "routeTree.gen" ||
+              nameWithoutExt === "Dockerfile" ||
+              nameWithoutExt.startsWith("__") ||
+              nameWithoutExt.endsWith(".gen") ||
+              nameWithoutExt === "vite-env"
+            ) {
+              return;
+            }
+
+            const kebabRegex =
+              /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+            if (!kebabRegex.test(nameWithoutExt)) {
+              context.report({
+                message: `Filename "${basename}" must use kebab-case (e.g., "my-component.tsx").`,
+                node,
+              });
+            }
+          },
+        };
+      },
+    },
+  },
+};
+
+export default plugin;