@sarj/eslint-plugin 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Custom ESLint rules collection for Sarj projects",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint src",

package/dist/rules/no-enum.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=no-enum.test.d.ts.map

package/dist/rules/no-enum.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-enum.test.d.ts","sourceRoot":"","sources":["../../src/rules/no-enum.test.ts"],"names":[],"mappings":""}

package/dist/rules/no-enum.test.js

@@ -1,44 +0,0 @@
-import { RuleTester } from "eslint";
-import { describe, it } from "vitest";
-import { noEnum } from "./no-enum.js";
-// Note: This test requires @typescript-eslint/parser to work properly
-// For now, we'll skip the actual test execution and just verify the rule exports correctly
-describe("no-enum", () => {
-    it("should export a valid rule module", () => {
-        if (!noEnum.meta || !noEnum.create) {
-            throw new Error("Rule is not properly exported");
-        }
-        if (noEnum.meta.type !== "suggestion") {
-            throw new Error("Expected rule type to be 'suggestion'");
-        }
-        if (!noEnum.meta.messages?.noEnum) {
-            throw new Error("Expected noEnum message to be defined");
-        }
-    });
-    // Full test requires TypeScript parser
-    it("should work with TypeScript parser", async () => {
-        const parser = await import("@typescript-eslint/parser");
-        const ruleTester = new RuleTester({
-            languageOptions: {
-                ecmaVersion: 2022,
-                sourceType: "module",
-                parser,
-            },
-        });
-        ruleTester.run("no-enum", noEnum, {
-            valid: [
-                // Union types are OK
-                { code: 'type Status = "active" | "inactive";' },
-                // Const objects are OK
-                { code: 'const Status = { ACTIVE: "active", INACTIVE: "inactive" } as const;' },
-            ],
-            invalid: [
-                // Regular enum
-                {
-                    code: "enum Status { Active, Inactive }",
-                    errors: [{ messageId: "noEnum" }],
-                },
-            ],
-        });
-    });
-});

package/dist/rules/no-raw-env.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=no-raw-env.test.d.ts.map

package/dist/rules/no-raw-env.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-raw-env.test.d.ts","sourceRoot":"","sources":["../../src/rules/no-raw-env.test.ts"],"names":[],"mappings":""}

package/dist/rules/no-raw-env.test.js

@@ -1,36 +0,0 @@
-import { RuleTester } from "eslint";
-import { describe, it } from "vitest";
-import { noRawEnv } from "./no-raw-env.js";
-const ruleTester = new RuleTester({
-    languageOptions: {
-        ecmaVersion: 2022,
-        sourceType: "module",
-    },
-});
-describe("no-raw-env", () => {
-    it("should pass valid and fail invalid cases", () => {
-        ruleTester.run("no-raw-env", noRawEnv, {
-            valid: [
-                // Using validated env schema
-                { code: 'const apiKey = env.API_KEY;' },
-                { code: 'const dbUrl = config.databaseUrl;' },
-                { code: 'const { NODE_ENV } = validatedEnv;' },
-            ],
-            invalid: [
-                // Direct process.env access
-                {
-                    code: 'const apiKey = process.env.API_KEY;',
-                    errors: [{ messageId: "noRawEnv" }],
-                },
-                {
-                    code: 'if (process.env.NODE_ENV === "production") {}',
-                    errors: [{ messageId: "noRawEnv" }],
-                },
-                {
-                    code: 'console.log(process.env.DEBUG);',
-                    errors: [{ messageId: "noRawEnv" }],
-                },
-            ],
-        });
-    });
-});

package/dist/rules/prefer-shadcn.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=prefer-shadcn.test.d.ts.map

package/dist/rules/prefer-shadcn.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prefer-shadcn.test.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-shadcn.test.ts"],"names":[],"mappings":""}

package/dist/rules/prefer-shadcn.test.js

@@ -1,58 +0,0 @@
-import { RuleTester } from "eslint";
-import { describe, it } from "vitest";
-import { preferShadcn } from "./prefer-shadcn.js";
-const ruleTester = new RuleTester({
-    languageOptions: {
-        ecmaVersion: 2022,
-        sourceType: "module",
-        parserOptions: {
-            ecmaFeatures: {
-                jsx: true,
-            },
-        },
-    },
-});
-describe("prefer-shadcn", () => {
-    it("should pass valid and fail invalid cases", () => {
-        ruleTester.run("prefer-shadcn", preferShadcn, {
-            valid: [
-                // shadcn components are OK
-                { code: '<Button onClick={handleClick}>Click me</Button>' },
-                { code: '<Input type="text" placeholder="Enter name" />' },
-                { code: '<Select value={value} onValueChange={setValue} />' },
-                { code: '<Table><TableBody /></Table>' },
-                // Other elements are OK
-                { code: '<div className="container">Content</div>' },
-                { code: '<span>Text</span>' },
-                { code: '<form onSubmit={handleSubmit}></form>' },
-            ],
-            invalid: [
-                // Native button
-                {
-                    code: '<button onClick={handleClick}>Click me</button>',
-                    errors: [{ messageId: "preferShadcn" }],
-                },
-                // Native input
-                {
-                    code: '<input type="text" placeholder="Enter name" />',
-                    errors: [{ messageId: "preferShadcn" }],
-                },
-                // Native select
-                {
-                    code: '<select value={value} onChange={handleChange}><option>A</option></select>',
-                    errors: [{ messageId: "preferShadcn" }],
-                },
-                // Native textarea
-                {
-                    code: '<textarea rows={5} />',
-                    errors: [{ messageId: "preferShadcn" }],
-                },
-                // Native table
-                {
-                    code: '<table><tbody /></table>',
-                    errors: [{ messageId: "preferShadcn" }],
-                },
-            ],
-        });
-    });
-});

package/dist/rules/require-assert-never.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=require-assert-never.test.d.ts.map

package/dist/rules/require-assert-never.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"require-assert-never.test.d.ts","sourceRoot":"","sources":["../../src/rules/require-assert-never.test.ts"],"names":[],"mappings":""}

package/dist/rules/require-assert-never.test.js

@@ -1,76 +0,0 @@
-import { RuleTester } from "eslint";
-import { describe, it } from "vitest";
-import { requireAssertNever } from "./require-assert-never.js";
-const ruleTester = new RuleTester({
-    languageOptions: {
-        ecmaVersion: 2022,
-        sourceType: "module",
-    },
-});
-describe("require-assert-never", () => {
-    it("should pass valid and fail invalid cases", () => {
-        ruleTester.run("require-assert-never", requireAssertNever, {
-            valid: [
-                // Switch with assertNever in default case
-                {
-                    code: `
-            switch (status) {
-              case "active":
-                return 1;
-              default:
-                assertNever(status);
-            }
-          `,
-                },
-                // Switch with throw assertNever
-                {
-                    code: `
-            switch (type) {
-              case "a":
-                break;
-              default:
-                throw assertNever(type);
-            }
-          `,
-                },
-                // Switch without default case is OK
-                {
-                    code: `
-            switch (value) {
-              case 1:
-                return "one";
-              case 2:
-                return "two";
-            }
-          `,
-                },
-            ],
-            invalid: [
-                // Default case without assertNever
-                {
-                    code: `
-            switch (status) {
-              case "active":
-                return 1;
-              default:
-                return 0;
-            }
-          `,
-                    errors: [{ messageId: "missingAssertNever" }],
-                },
-                // Empty default case
-                {
-                    code: `
-            switch (type) {
-              case "a":
-                break;
-              default:
-                break;
-            }
-          `,
-                    errors: [{ messageId: "missingAssertNever" }],
-                },
-            ],
-        });
-    });
-});

package/dist/rules/zod-naming-convention.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=zod-naming-convention.test.d.ts.map

package/dist/rules/zod-naming-convention.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zod-naming-convention.test.d.ts","sourceRoot":"","sources":["../../src/rules/zod-naming-convention.test.ts"],"names":[],"mappings":""}

package/dist/rules/zod-naming-convention.test.js

@@ -1,38 +0,0 @@
-import { RuleTester } from "eslint";
-import { describe, it } from "vitest";
-import { zodNamingConvention } from "./zod-naming-convention.js";
-const ruleTester = new RuleTester({
-    languageOptions: {
-        ecmaVersion: 2022,
-        sourceType: "module",
-    },
-});
-describe("zod-naming-convention", () => {
-    it("should pass valid and fail invalid cases", () => {
-        ruleTester.run("zod-naming-convention", zodNamingConvention, {
-            valid: [
-                // Correct naming with Z prefix
-                { code: 'const ZUserSchema = z.object({ name: z.string() });' },
-                { code: 'const ZConfig = z.object({ port: z.number() });' },
-                { code: 'const ZResponse = z.object({}).extend({});' },
-                // Non-Zod variables are fine
-                { code: 'const userSchema = createSchema();' },
-                { code: 'const config = { name: "test" };' },
-            ],
-            invalid: [
-                {
-                    code: 'const userSchema = z.object({ name: z.string() });',
-                    errors: [{ messageId: "zodPrefix" }],
-                },
-                {
-                    code: 'const schema = z.string();',
-                    errors: [{ messageId: "zodPrefix" }],
-                },
-                {
-                    code: 'const config = z.object({}).extend({ port: z.number() });',
-                    errors: [{ messageId: "zodPrefix" }],
-                },
-            ],
-        });
-    });
-});