@blogic-cz/oxc-config 1.3.0 → 1.4.1

package/.oxlintrc.ts.json

@@ -1,9 +1,9 @@
 {
   "$schema": "https://raw.githubusercontent.com/niconiconainu/oxc/HEAD/npm/oxc-types/src/generated/schema/oxlintrc.json",
   "jsPlugins": [
-    "./plugins/effect-ts.js",
-    "./plugins/enforce-props-type-name.js",
-    "./plugins/max-file-lines.js"
+    "./dist/plugins/effect-ts.js",
+    "./dist/plugins/enforce-props-type-name.js",
+    "./dist/plugins/max-file-lines.js"
   ],
   "plugins": [
     "import",
@@ -85,6 +85,7 @@
     "naming/no-console-in-server": "error",
     "naming/no-dynamic-type-import": "error",
     "naming/no-server-logger-in-client": "error",
+    "naming/no-process-env": "error",
     "naming/no-undefined-parameter-union": "error",
     "effect-ts/no-direct-tag-check": "error"
   },
@@ -126,6 +127,7 @@
         "import/no-relative-parent-imports": "off",
         "naming/enforce-props-type-name": "off",
         "naming/no-default-parameter-values": "off",
+        "naming/no-process-env": "off",
         "naming/no-undefined-parameter-union": "off",
         "typescript/no-unsafe-type-assertion": "off",
         "unicorn/no-array-sort": "off"

package/dist/index.d.ts

@@ -0,0 +1,141 @@
+import effectTs from "./plugins/effect-ts";
+import enforcePropsTypeName from "./plugins/enforce-props-type-name";
+import maxFileLines from "./plugins/max-file-lines";
+export { effectTs, enforcePropsTypeName, maxFileLines, };
+export declare const oxlintTsConfigPath = "@blogic-cz/oxc-config/oxlint/ts";
+export declare const oxlintTsReactConfigPath = "@blogic-cz/oxc-config/oxlint/ts-react";
+export declare const oxfmtBaseConfigPath = "@blogic-cz/oxc-config/oxfmt/base";
+export declare const oxlintPlugins: {
+    effectTs: {
+        meta: {
+            name: string;
+        };
+        rules: {
+            "no-direct-tag-check": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    BinaryExpression(node: any): void;
+                    SwitchStatement(node: any): void;
+                };
+            };
+        };
+    };
+    enforcePropsTypeName: {
+        meta: {
+            name: string;
+        };
+        rules: {
+            "enforce-props-type-name": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    TSTypeAliasDeclaration(node: any): void;
+                };
+            };
+            "no-dynamic-type-import": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    TSImportType(node: any): void;
+                };
+            };
+            "no-server-logger-in-client": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    ImportDeclaration(node: any): void;
+                };
+            };
+            "no-console-in-server": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    MemberExpression(node: any): void;
+                };
+            };
+            "no-default-parameter-values": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    AssignmentPattern(node: any): void;
+                };
+            };
+            "no-process-env": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    MemberExpression(node: any): void;
+                };
+            };
+            "no-undefined-parameter-union": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    TSUndefinedKeyword(node: any): void;
+                };
+            };
+        };
+    };
+    maxFileLines: {
+        meta: {
+            name: string;
+        };
+        rules: {
+            "max-file-lines": {
+                meta: {
+                    defaultOptions: {
+                        maxLines: number;
+                        extensions: string[];
+                    }[];
+                    schema: {
+                        type: string;
+                        default: {};
+                        properties: {
+                            maxLines: {
+                                type: string;
+                                default: number;
+                            };
+                            extensions: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                                default: string[];
+                            };
+                        };
+                        additionalProperties: boolean;
+                    }[];
+                };
+                create(context: any): {
+                    Program(): void;
+                };
+            };
+            "no-barrel-files": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    Program(node: any): void;
+                };
+            };
+            "kebab-case-filename": {
+                meta: {
+                    schema: any[];
+                };
+                create(context: any): {
+                    Program(node: any): void;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,qBAAqB,CAAC;AAC3C,OAAO,oBAAoB,MAAM,mCAAmC,CAAC;AACrE,OAAO,YAAY,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,YAAY,GACb,CAAC;AAEF,eAAO,MAAM,kBAAkB,oCACI,CAAC;AACpC,eAAO,MAAM,uBAAuB,0CACK,CAAC;AAC1C,eAAO,MAAM,mBAAmB,qCACI,CAAC;AAErC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIzB,CAAC"}

package/dist/index.js

@@ -0,0 +1,381 @@
+// src/plugins/effect-ts.ts
+var EFFECT_TAGS = {
+  Some: "Use `Option.isSome(value)` or `Option.match(value, { onSome, onNone })`.",
+  None: "Use `Option.isNone(value)` or `Option.match(value, { onSome, onNone })`.",
+  Left: "Use `Either.isLeft(value)` or `Either.match(value, { onLeft, onRight })`.",
+  Right: "Use `Either.isRight(value)` or `Either.match(value, { onLeft, onRight })`.",
+  Success: "Use `Exit.isSuccess(value)` or `Exit.match(value, { onSuccess, onFailure })`.",
+  Failure: "Use `Exit.isFailure(value)` or `Exit.match(value, { onSuccess, onFailure })`."
+};
+var TAG_PROPERTY = "_tag";
+var isMemberAccessOnTag = (node) => node.type === "MemberExpression" && !node.computed && node.property?.type === "Identifier" && node.property.name === TAG_PROPERTY;
+var isEffectTagLiteral = (node) => {
+  if (node.type === "StringLiteral" && typeof node.value === "string") {
+    return node.value in EFFECT_TAGS ? node.value : undefined;
+  }
+  return;
+};
+var plugin = {
+  meta: {
+    name: "effect-ts"
+  },
+  rules: {
+    "no-direct-tag-check": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          BinaryExpression(node) {
+            if (node.operator !== "===" && node.operator !== "!==" && node.operator !== "==" && node.operator !== "!=") {
+              return;
+            }
+            let tag;
+            if (isMemberAccessOnTag(node.left)) {
+              tag = isEffectTagLiteral(node.right);
+            } else if (isMemberAccessOnTag(node.right)) {
+              tag = isEffectTagLiteral(node.left);
+            }
+            if (tag === undefined) {
+              return;
+            }
+            const hint = EFFECT_TAGS[tag];
+            context.report({
+              message: `Do not check \`._tag\` directly for "${tag}". ${hint}`,
+              node
+            });
+          },
+          SwitchStatement(node) {
+            if (!isMemberAccessOnTag(node.discriminant)) {
+              return;
+            }
+            const effectCases = node.cases.filter((c) => c.test && c.test.type === "StringLiteral" && typeof c.test.value === "string" && (c.test.value in EFFECT_TAGS));
+            if (effectCases.length === 0) {
+              return;
+            }
+            const tags = effectCases.map((c) => `"${c.test.value}"`).join(", ");
+            context.report({
+              message: `Do not switch on \`._tag\` with Effect tags (${tags}). Use the \`.pipe(T.match(...))\` API instead.`,
+              node: node.discriminant
+            });
+          }
+        };
+      }
+    }
+  }
+};
+var effect_ts_default = plugin;
+
+// src/plugins/enforce-props-type-name.ts
+var isFunctionNode = (type) => type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression" || type === "TSDeclareFunction";
+var plugin2 = {
+  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-process-env": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          MemberExpression(node) {
+            if (node.object.type !== "Identifier" || node.object.name !== "process") {
+              return;
+            }
+            const isEnvAccess = !node.computed && node.property.type === "Identifier" && node.property.name === "env" || node.computed && node.property.type === "StringLiteral" && node.property.value === "env";
+            if (!isEnvAccess) {
+              return;
+            }
+            const filename = context.filename;
+            const parts = filename.split("/");
+            const basename = parts.at(-1) ?? "";
+            if (basename === "env.ts" || basename.startsWith("env.") || basename === "public-env.ts" || parts.includes("env")) {
+              return;
+            }
+            context.report({
+              message: 'Do not access `process.env` directly. Import the typed `env` object from the env module instead (e.g., `import { env } from "@/env/env.server"`).',
+              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 = plugin2;
+
+// src/plugins/max-file-lines.ts
+function parseOptions(value) {
+  if (typeof value !== "object" || value === null) {
+    return { maxLines: 500, extensions: [".tsx"] };
+  }
+  const maxLinesValue = "maxLines" in value ? value.maxLines : undefined;
+  const maxLines = typeof maxLinesValue === "number" ? maxLinesValue : 500;
+  const extensionsValue = "extensions" in value ? value.extensions : undefined;
+  const extensions = Array.isArray(extensionsValue) ? extensionsValue.filter((extension) => typeof extension === "string") : [".tsx"];
+  return {
+    maxLines,
+    extensions: extensions.length > 0 ? extensions : [".tsx"]
+  };
+}
+var plugin3 = {
+  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 = plugin3;
+
+// src/index.ts
+var oxlintTsConfigPath = "@blogic-cz/oxc-config/oxlint/ts";
+var oxlintTsReactConfigPath = "@blogic-cz/oxc-config/oxlint/ts-react";
+var oxfmtBaseConfigPath = "@blogic-cz/oxc-config/oxfmt/base";
+var oxlintPlugins = {
+  effectTs: effect_ts_default,
+  enforcePropsTypeName: enforce_props_type_name_default,
+  maxFileLines: max_file_lines_default
+};
+export {
+  oxlintTsReactConfigPath,
+  oxlintTsConfigPath,
+  oxlintPlugins,
+  oxfmtBaseConfigPath,
+  max_file_lines_default as maxFileLines,
+  enforce_props_type_name_default as enforcePropsTypeName,
+  effect_ts_default as effectTs
+};

package/dist/plugins/effect-ts.d.ts

@@ -0,0 +1,18 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-direct-tag-check": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                BinaryExpression(node: any): void;
+                SwitchStatement(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=effect-ts.d.ts.map

package/dist/plugins/effect-ts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-ts.d.ts","sourceRoot":"","sources":["../../src/plugins/effect-ts.ts"],"names":[],"mappings":"AA+BA,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;CAuEX,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/{plugins → dist/plugins}/effect-ts.js

@@ -1,4 +1,4 @@
-// plugins/effect-ts.ts
+// src/plugins/effect-ts.ts
 var EFFECT_TAGS = {
   Some: "Use `Option.isSome(value)` or `Option.match(value, { onSome, onNone })`.",
   None: "Use `Option.isNone(value)` or `Option.match(value, { onSome, onNone })`.",

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

@@ -0,0 +1,65 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "enforce-props-type-name": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                TSTypeAliasDeclaration(node: any): void;
+            };
+        };
+        "no-dynamic-type-import": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                TSImportType(node: any): void;
+            };
+        };
+        "no-server-logger-in-client": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                ImportDeclaration(node: any): void;
+            };
+        };
+        "no-console-in-server": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                MemberExpression(node: any): void;
+            };
+        };
+        "no-default-parameter-values": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                AssignmentPattern(node: any): void;
+            };
+        };
+        "no-process-env": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                MemberExpression(node: any): void;
+            };
+        };
+        "no-undefined-parameter-union": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                TSUndefinedKeyword(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=enforce-props-type-name.d.ts.map

package/dist/plugins/enforce-props-type-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-props-type-name.d.ts","sourceRoot":"","sources":["../../src/plugins/enforce-props-type-name.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqOX,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/{plugins → dist/plugins}/enforce-props-type-name.js

@@ -1,4 +1,4 @@
-// plugins/enforce-props-type-name.ts
+// src/plugins/enforce-props-type-name.ts
 var isFunctionNode = (type) => type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression" || type === "TSDeclareFunction";
 var plugin = {
   meta: {
@@ -100,6 +100,34 @@ var plugin = {
         };
       }
     },
+    "no-process-env": {
+      meta: {
+        schema: []
+      },
+      create(context) {
+        return {
+          MemberExpression(node) {
+            if (node.object.type !== "Identifier" || node.object.name !== "process") {
+              return;
+            }
+            const isEnvAccess = !node.computed && node.property.type === "Identifier" && node.property.name === "env" || node.computed && node.property.type === "StringLiteral" && node.property.value === "env";
+            if (!isEnvAccess) {
+              return;
+            }
+            const filename = context.filename;
+            const parts = filename.split("/");
+            const basename = parts.at(-1) ?? "";
+            if (basename === "env.ts" || basename.startsWith("env.") || basename === "public-env.ts" || parts.includes("env")) {
+              return;
+            }
+            context.report({
+              message: 'Do not access `process.env` directly. Import the typed `env` object from the env module instead (e.g., `import { env } from "@/env/env.server"`).',
+              node
+            });
+          }
+        };
+      }
+    },
     "no-undefined-parameter-union": {
       meta: {
         schema: []

package/dist/plugins/max-file-lines.d.ts

@@ -0,0 +1,54 @@
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "max-file-lines": {
+            meta: {
+                defaultOptions: {
+                    maxLines: number;
+                    extensions: string[];
+                }[];
+                schema: {
+                    type: string;
+                    default: {};
+                    properties: {
+                        maxLines: {
+                            type: string;
+                            default: number;
+                        };
+                        extensions: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                            default: string[];
+                        };
+                    };
+                    additionalProperties: boolean;
+                }[];
+            };
+            create(context: any): {
+                Program(): void;
+            };
+        };
+        "no-barrel-files": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                Program(node: any): void;
+            };
+        };
+        "kebab-case-filename": {
+            meta: {
+                schema: any[];
+            };
+            create(context: any): {
+                Program(node: any): void;
+            };
+        };
+    };
+};
+export default plugin;
+//# sourceMappingURL=max-file-lines.d.ts.map

package/dist/plugins/max-file-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-file-lines.d.ts","sourceRoot":"","sources":["../../src/plugins/max-file-lines.ts"],"names":[],"mappings":"AA6BA,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoKX,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/{plugins → dist/plugins}/max-file-lines.js

@@ -1,10 +1,12 @@
-// plugins/max-file-lines.ts
+// src/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"];
+  const maxLinesValue = "maxLines" in value ? value.maxLines : undefined;
+  const maxLines = typeof maxLinesValue === "number" ? maxLinesValue : 500;
+  const extensionsValue = "extensions" in value ? value.extensions : undefined;
+  const extensions = Array.isArray(extensionsValue) ? extensionsValue.filter((extension) => typeof extension === "string") : [".tsx"];
   return {
     maxLines,
     extensions: extensions.length > 0 ? extensions : [".tsx"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/oxc-config",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Shared oxlint and oxfmt configs for blogic projects — layered TypeScript, React, and formatter presets",
   "keywords": [
     "oxlint",
@@ -20,19 +20,69 @@
     "type": "git",
     "url": "https://github.com/blogic-cz/oxc-config.git"
   },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./plugins/effect-ts": {
+      "types": "./dist/plugins/effect-ts.d.ts",
+      "import": "./dist/plugins/effect-ts.js",
+      "default": "./dist/plugins/effect-ts.js"
+    },
+    "./plugins/effect-ts.js": {
+      "types": "./dist/plugins/effect-ts.d.ts",
+      "import": "./dist/plugins/effect-ts.js",
+      "default": "./dist/plugins/effect-ts.js"
+    },
+    "./plugins/enforce-props-type-name": {
+      "types": "./dist/plugins/enforce-props-type-name.d.ts",
+      "import": "./dist/plugins/enforce-props-type-name.js",
+      "default": "./dist/plugins/enforce-props-type-name.js"
+    },
+    "./plugins/enforce-props-type-name.js": {
+      "types": "./dist/plugins/enforce-props-type-name.d.ts",
+      "import": "./dist/plugins/enforce-props-type-name.js",
+      "default": "./dist/plugins/enforce-props-type-name.js"
+    },
+    "./plugins/max-file-lines": {
+      "types": "./dist/plugins/max-file-lines.d.ts",
+      "import": "./dist/plugins/max-file-lines.js",
+      "default": "./dist/plugins/max-file-lines.js"
+    },
+    "./plugins/max-file-lines.js": {
+      "types": "./dist/plugins/max-file-lines.d.ts",
+      "import": "./dist/plugins/max-file-lines.js",
+      "default": "./dist/plugins/max-file-lines.js"
+    },
+    "./oxlint/ts": "./.oxlintrc.ts.json",
+    "./oxlint/ts-react": "./.oxlintrc.ts-react.json",
+    "./oxfmt/base": "./.oxfmtrc.base.jsonc",
+    "./package.json": "./package.json"
+  },
   "files": [
+    "dist",
+    "src",
     ".oxlintrc.ts.json",
     ".oxlintrc.ts-react.json",
     ".oxfmtrc.base.jsonc",
-    "plugins/*.js",
-    "plugins/*.ts",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun build plugins/effect-ts.ts --outdir plugins --outfile effect-ts.js && 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",
+    "clean": "rm -rf dist",
+    "build:js": "bun run clean && bun build src/index.ts --outdir dist && bun build src/plugins/effect-ts.ts --outdir dist/plugins --outfile effect-ts.js && bun build src/plugins/enforce-props-type-name.ts --outdir dist/plugins --outfile enforce-props-type-name.js && bun build src/plugins/max-file-lines.ts --outdir dist/plugins --outfile max-file-lines.js",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build": "bun run build:js && bun run build:types",
     "prepublishOnly": "bun run build"
   },
+  "devDependencies": {
+    "typescript": "5.9.3"
+  },
   "publishConfig": {
     "access": "public"
   }

package/src/index.ts

@@ -0,0 +1,22 @@
+import effectTs from "./plugins/effect-ts";
+import enforcePropsTypeName from "./plugins/enforce-props-type-name";
+import maxFileLines from "./plugins/max-file-lines";
+
+export {
+  effectTs,
+  enforcePropsTypeName,
+  maxFileLines,
+};
+
+export const oxlintTsConfigPath =
+  "@blogic-cz/oxc-config/oxlint/ts";
+export const oxlintTsReactConfigPath =
+  "@blogic-cz/oxc-config/oxlint/ts-react";
+export const oxfmtBaseConfigPath =
+  "@blogic-cz/oxc-config/oxfmt/base";
+
+export const oxlintPlugins = {
+  effectTs,
+  enforcePropsTypeName,
+  maxFileLines,
+};

package/{plugins → src/plugins}/effect-ts.ts

@@ -1,5 +1,3 @@
-import type { Plugin } from "#oxlint/plugins";
-
 const EFFECT_TAGS: Record<string, string> = {
   Some: 'Use `Option.isSome(value)` or `Option.match(value, { onSome, onNone })`.',
   None: 'Use `Option.isNone(value)` or `Option.match(value, { onSome, onNone })`.',
@@ -31,7 +29,7 @@ const isEffectTagLiteral = (node: {
   return undefined;
 };
 
-const plugin: Plugin = {
+const plugin = {
   meta: {
     name: "effect-ts",
   },

package/{plugins → src/plugins}/enforce-props-type-name.ts

@@ -1,12 +1,10 @@
-import type { Plugin } from "#oxlint/plugins";
-
 const isFunctionNode = (type: string): boolean =>
   type === "FunctionDeclaration" ||
   type === "FunctionExpression" ||
   type === "ArrowFunctionExpression" ||
   type === "TSDeclareFunction";
 
-const plugin: Plugin = {
+const plugin = {
   meta: {
     name: "naming",
   },
@@ -138,6 +136,54 @@ const plugin: Plugin = {
         };
       },
     },
+    "no-process-env": {
+      meta: {
+        schema: [],
+      },
+      create(context) {
+        return {
+          MemberExpression(node) {
+            if (
+              node.object.type !== "Identifier" ||
+              node.object.name !== "process"
+            ) {
+              return;
+            }
+
+            const isEnvAccess =
+              (!node.computed &&
+                node.property.type === "Identifier" &&
+                node.property.name === "env") ||
+              (node.computed &&
+                node.property.type === "StringLiteral" &&
+                node.property.value === "env");
+
+            if (!isEnvAccess) {
+              return;
+            }
+
+            const filename = context.filename;
+            const parts = filename.split("/");
+            const basename = parts.at(-1) ?? "";
+
+            if (
+              basename === "env.ts" ||
+              basename.startsWith("env.") ||
+              basename === "public-env.ts" ||
+              parts.includes("env")
+            ) {
+              return;
+            }
+
+            context.report({
+              message:
+                'Do not access `process.env` directly. Import the typed `env` object from the env module instead (e.g., `import { env } from "@/env/env.server"`).',
+              node,
+            });
+          },
+        };
+      },
+    },
     "no-undefined-parameter-union": {
       meta: {
         schema: [],

package/{plugins → src/plugins}/max-file-lines.ts

@@ -1,5 +1,3 @@
-import type { Plugin } from "#oxlint/plugins";
-
 function parseOptions(value: unknown): {
   maxLines: number;
   extensions: string[];
@@ -8,12 +6,16 @@ function parseOptions(value: unknown): {
     return { maxLines: 500, extensions: [".tsx"] };
   }
 
+  const maxLinesValue =
+    "maxLines" in value ? value.maxLines : undefined;
   const maxLines =
-    typeof value.maxLines === "number"
-      ? value.maxLines
+    typeof maxLinesValue === "number"
+      ? maxLinesValue
       : 500;
-  const extensions = Array.isArray(value.extensions)
-    ? value.extensions.filter(
+  const extensionsValue =
+    "extensions" in value ? value.extensions : undefined;
+  const extensions = Array.isArray(extensionsValue)
+    ? extensionsValue.filter(
         (extension) => typeof extension === "string"
       )
     : [".tsx"];
@@ -25,7 +27,7 @@ function parseOptions(value: unknown): {
   };
 }
 
-const plugin: Plugin = {
+const plugin = {
   meta: {
     name: "file-quality",
   },
@@ -93,12 +95,10 @@ const plugin: Plugin = {
           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;
             }
@@ -136,7 +136,6 @@ const plugin: Plugin = {
           Program(node) {
             const filename = context.filename;
 
-            // Skip node_modules and .d.ts files
             if (
               filename.includes("node_modules") ||
               filename.endsWith(".d.ts")
@@ -150,7 +149,6 @@ const plugin: Plugin = {
               return;
             }
 
-            // Skip TanStack Router dynamic segments ($param, $, [param])
             if (
               basename.includes("$") ||
               basename.includes("[") ||
@@ -159,7 +157,6 @@ const plugin: Plugin = {
               return;
             }
 
-            // Strip compound extensions first, then simple
             const nameWithoutExt = basename
               .replace(
                 /\.(test|e2e|server|client|config)\.(ts|tsx|js|jsx|mjs|cjs)$/,
@@ -167,12 +164,10 @@ const plugin: Plugin = {
               )
               .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" ||