@simplysm/lint 13.0.69 → 13.0.71

package/tests/no-subpath-imports-from-simplysm.spec.ts

@@ -0,0 +1,352 @@
+import "./vitest.setup";
+import { describe } from "vitest";
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import rule from "../src/rules/no-subpath-imports-from-simplysm";
+
+const ruleTester = new RuleTester();
+
+describe("no-subpath-imports-from-simplysm rule", () => {
+  describe("allowed code (valid)", () => {
+    describe("package root import is allowed", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [
+          {
+            code: `import { Something } from "@simplysm/sd-core-common";`,
+          },
+        ],
+        invalid: [],
+      });
+    });
+
+    describe("subpath import other than src is allowed", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [
+          {
+            code: `import { Something } from "@simplysm/sd-core-common/utils";`,
+          },
+          {
+            code: `import { Something } from "@simplysm/sd-core-common/types/DateOnly";`,
+          },
+        ],
+        invalid: [],
+      });
+    });
+
+    describe("packages other than @simplysm are allowed", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [
+          {
+            code: `import { Something } from "@angular/core";`,
+          },
+          {
+            code: `import { Something } from "lodash/src/utils";`,
+          },
+        ],
+        invalid: [],
+      });
+    });
+
+    describe("dynamic import - path other than src is allowed", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [
+          {
+            code: `const mod = await import("@simplysm/sd-core-common");`,
+          },
+          {
+            code: `const mod = await import("@simplysm/sd-core-common/utils");`,
+          },
+        ],
+        invalid: [],
+      });
+    });
+
+    describe("re-export - path other than src is allowed", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [
+          {
+            code: `export { Something } from "@simplysm/sd-core-common";`,
+          },
+          {
+            code: `export * from "@simplysm/sd-core-common/utils";`,
+          },
+        ],
+        invalid: [],
+      });
+    });
+  });
+
+  describe("code that should cause errors (invalid)", () => {
+    describe("@simplysm/*/src import is prohibited", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import { Something } from "@simplysm/sd-core-common/src";`,
+            output: `import { Something } from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("@simplysm/*/src/xxx import is prohibited", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import { DateOnly } from "@simplysm/sd-core-common/src/types/DateOnly";`,
+            output: `import { DateOnly } from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/types/DateOnly",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src import prohibited from multiple packages", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import { SdServiceClient } from "@simplysm/sd-service-client/src/SdServiceClient";`,
+            output: `import { SdServiceClient } from "@simplysm/sd-service-client";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-service-client",
+                  importPath: "@simplysm/sd-service-client/src/SdServiceClient",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in dynamic import", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `const mod = await import("@simplysm/sd-core-common/src/utils");`,
+            output: `const mod = await import("@simplysm/sd-core-common");`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/utils",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in re-export", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `export { Something } from "@simplysm/sd-core-common/src/types";`,
+            output: `export { Something } from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/types",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in export * from", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `export * from "@simplysm/sd-core-common/src/types";`,
+            output: `export * from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/types",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("preserve quote style when using single quotes", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import { Something } from '@simplysm/sd-core-common/src';`,
+            output: `import { Something } from '@simplysm/sd-core-common';`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in type-only import", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import type { DateOnly } from "@simplysm/sd-core-common/src/types";`,
+            output: `import type { DateOnly } from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/types",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in export type", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `export type { DateOnly } from "@simplysm/sd-core-common/src/types";`,
+            output: `export type { DateOnly } from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/types",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in namespace import", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import * as CoreCommon from "@simplysm/sd-core-common/src";`,
+            output: `import * as CoreCommon from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in side-effect import", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import "@simplysm/sd-core-common/src/polyfills";`,
+            output: `import "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/polyfills",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in default import", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import SomeDefault from "@simplysm/sd-core-common/src/default";`,
+            output: `import SomeDefault from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src/default",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    describe("src path prohibited in mixed import (default + named)", () => {
+      ruleTester.run("no-subpath-imports-from-simplysm", rule, {
+        valid: [],
+        invalid: [
+          {
+            code: `import SomeDefault, { Something } from "@simplysm/sd-core-common/src";`,
+            output: `import SomeDefault, { Something } from "@simplysm/sd-core-common";`,
+            errors: [
+              {
+                messageId: "noSubpathImport",
+                data: {
+                  pkg: "sd-core-common",
+                  importPath: "@simplysm/sd-core-common/src",
+                },
+              },
+            ],
+          },
+        ],
+      });
+    });
+  });
+});

package/tests/recommended.spec.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect } from "vitest";
+import recommended from "../src/eslint-recommended";
+import plugin from "../src/eslint-plugin";
+
+// ESLint config type helper
+type ConfigItem = (typeof recommended)[number];
+
+const hasIgnores = (config: ConfigItem): config is ConfigItem & { ignores: string[] } => {
+  return "ignores" in config && Array.isArray(config.ignores);
+};
+
+const hasFiles = (config: ConfigItem): config is ConfigItem & { files: (string | string[])[] } => {
+  return "files" in config && Array.isArray(config.files);
+};
+
+const hasRules = (
+  config: ConfigItem,
+): config is ConfigItem & { rules: Record<string, unknown> } => {
+  return "rules" in config && config.rules != null;
+};
+
+const hasPlugins = (
+  config: ConfigItem,
+): config is ConfigItem & { plugins: Record<string, unknown> } => {
+  return "plugins" in config && config.plugins != null;
+};
+
+const flattenFiles = (files: (string | string[])[]): string[] => {
+  return files.flat();
+};
+
+describe("recommended config", () => {
+  it("should export as array", () => {
+    expect(Array.isArray(recommended)).toBe(true);
+    expect(recommended.length).toBeGreaterThan(0);
+  });
+
+  it("should include globalIgnores config", () => {
+    const ignoresConfig = recommended.find(hasIgnores);
+    expect(ignoresConfig).toBeDefined();
+    if (ignoresConfig == null) return;
+
+    const expectedPatterns = ["**/node_modules/**", "**/dist/**", "**/.*/**", "**/_*/**"];
+    expect(ignoresConfig.ignores).toEqual(expect.arrayContaining(expectedPatterns));
+  });
+
+  it("should include JS file config", () => {
+    const jsConfig = recommended.find(
+      (config) => hasFiles(config) && flattenFiles(config.files).some((f) => f.includes("*.js")),
+    );
+    expect(jsConfig).toBeDefined();
+    if (jsConfig == null) return;
+    if (hasPlugins(jsConfig)) {
+      expect(jsConfig.plugins).toHaveProperty("@simplysm");
+    }
+  });
+
+  it("should include TS file config", () => {
+    const tsConfig = recommended.find(
+      (config) => hasFiles(config) && flattenFiles(config.files).some((f) => f.includes("*.ts")),
+    );
+    expect(tsConfig).toBeDefined();
+    if (tsConfig == null) return;
+    if (hasPlugins(tsConfig)) {
+      expect(tsConfig.plugins).toHaveProperty("@typescript-eslint");
+      expect(tsConfig.plugins).toHaveProperty("@simplysm");
+    }
+  });
+
+  it("should enable @simplysm custom rules with correct severity in TS config", () => {
+    const tsConfig = recommended.find(
+      (config) => hasFiles(config) && flattenFiles(config.files).some((f) => f.includes("*.ts")),
+    );
+    expect(tsConfig).toBeDefined();
+    if (tsConfig == null) return;
+    if (hasRules(tsConfig)) {
+      expect(tsConfig.rules).toHaveProperty("@simplysm/no-hard-private", "error");
+      expect(tsConfig.rules).toHaveProperty("@simplysm/no-subpath-imports-from-simplysm", "error");
+      expect(tsConfig.rules).toHaveProperty("@simplysm/ts-no-throw-not-implemented-error", "warn");
+    }
+  });
+
+  it("should enable @simplysm custom rules in JS config", () => {
+    const jsConfig = recommended.find(
+      (config) => hasFiles(config) && flattenFiles(config.files).some((f) => f.includes("*.js")),
+    );
+    expect(jsConfig).toBeDefined();
+    if (jsConfig == null) return;
+    if (hasRules(jsConfig)) {
+      expect(jsConfig.rules).toHaveProperty("@simplysm/no-hard-private", "error");
+      expect(jsConfig.rules).toHaveProperty("@simplysm/no-subpath-imports-from-simplysm", "error");
+    }
+  });
+
+  it("should disable import/no-extraneous-dependencies in test folder", () => {
+    const testConfig = recommended.find(
+      (config) =>
+        hasFiles(config) && flattenFiles(config.files).some((f) => f.includes("**/tests/**")),
+    );
+    expect(testConfig).toBeDefined();
+    if (testConfig == null) return;
+    if (hasRules(testConfig)) {
+      expect(testConfig.rules).toHaveProperty("import/no-extraneous-dependencies", "off");
+    }
+  });
+
+  it("should include all plugin.rules in recommended config", () => {
+    const tsConfig = recommended.find(
+      (config) => hasFiles(config) && flattenFiles(config.files).some((f) => f.includes("*.ts")),
+    );
+    expect(tsConfig).toBeDefined();
+    if (tsConfig == null) return;
+
+    if (hasRules(tsConfig)) {
+      const ruleNames = Object.keys(plugin.rules);
+      for (const ruleName of ruleNames) {
+        const fullRuleName = `@simplysm/${ruleName}`;
+        expect(tsConfig.rules, `rule '${fullRuleName}' should be included in TS config`).toHaveProperty(
+          fullRuleName,
+        );
+      }
+    }
+  });
+
+  it("should set parserOptions.project to true in TS config", () => {
+    const tsConfig = recommended.find(
+      (config) => hasFiles(config) && flattenFiles(config.files).some((f) => f.includes("*.ts")),
+    ) as ConfigItem & {
+      languageOptions?: { parserOptions?: { project?: unknown } };
+    };
+    expect(tsConfig).toBeDefined();
+    expect(tsConfig.languageOptions?.parserOptions?.project).toBe(true);
+  });
+
+  it("should apply solid plugin to TSX files", () => {
+    // Find config that includes solid plugin and handles .tsx files
+    // (in current implementation, **/*.ts and **/*.tsx are handled together)
+    const tsxSolidConfig = recommended.find(
+      (config) =>
+        hasFiles(config) &&
+        flattenFiles(config.files).some((f) => f.includes(".tsx")) &&
+        hasPlugins(config) &&
+        "solid" in config.plugins,
+    );
+    expect(tsxSolidConfig).toBeDefined();
+    if (tsxSolidConfig == null) return;
+    if (hasPlugins(tsxSolidConfig)) {
+      expect(tsxSolidConfig.plugins).toHaveProperty("solid");
+    }
+    if (hasRules(tsxSolidConfig)) {
+      // eslint-plugin-solid flat/typescript rules should be applied
+      expect(tsxSolidConfig.rules).toHaveProperty("solid/jsx-no-undef");
+    }
+  });
+});