@api-extractor-tools/eslint-plugin 0.1.0-alpha.0 → 0.1.0-alpha.1

package/test/rules/incompatible-release-tags.test.ts

@@ -0,0 +1,340 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import { describe, it, afterAll } from 'vitest'
+import * as tseslintParser from '@typescript-eslint/parser'
+import { incompatibleReleaseTags } from '../../src/rules/incompatible-release-tags'
+
+RuleTester.afterAll = afterAll
+RuleTester.describe = describe
+RuleTester.it = it
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: tseslintParser,
+    parserOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+    },
+  },
+})
+
+describe('incompatible-release-tags', () => {
+  ruleTester.run('incompatible-release-tags', incompatibleReleaseTags, {
+    valid: [
+      // Public API using public type
+      {
+        code: `
+/**
+ * A public interface.
+ * @public
+ */
+export interface MyInterface {
+  name: string;
+}
+
+/**
+ * A public function.
+ * @public
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+      },
+      // Public API using beta type (beta is less visible, but this is OK since beta >= beta in some interpretations)
+      // Actually, let's make this more strict - public should only use public
+      {
+        code: `
+/**
+ * A beta interface.
+ * @beta
+ */
+export interface MyInterface {
+  name: string;
+}
+
+/**
+ * A beta function.
+ * @beta
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+      },
+      // Alpha API using alpha type
+      {
+        code: `
+/**
+ * An alpha interface.
+ * @alpha
+ */
+export interface MyInterface {
+  name: string;
+}
+
+/**
+ * An alpha function.
+ * @alpha
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+      },
+      // Internal API using internal type
+      {
+        code: `
+/**
+ * An internal interface.
+ * @internal
+ */
+export interface MyInterface {
+  name: string;
+}
+
+/**
+ * An internal function.
+ * @internal
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+      },
+      // Beta API using public type (more visible)
+      {
+        code: `
+/**
+ * A public interface.
+ * @public
+ */
+export interface MyInterface {
+  name: string;
+}
+
+/**
+ * A beta function.
+ * @beta
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+      },
+      // Alpha API using public type (more visible)
+      {
+        code: `
+/**
+ * A public interface.
+ * @public
+ */
+export interface MyInterface {
+  name: string;
+}
+
+/**
+ * An alpha function.
+ * @alpha
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+      },
+    ],
+    invalid: [
+      // Public API using internal type
+      {
+        code: `
+/**
+ * An internal interface.
+ * @internal
+ */
+interface MyInterface {
+  name: string;
+}
+
+/**
+ * A public function.
+ * @public
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+        errors: [
+          {
+            messageId: 'incompatibleReleaseTags',
+            data: {
+              exportedName: 'myFunction',
+              exportedTag: '@public',
+              referencedName: 'MyInterface',
+              referencedTag: '@internal',
+            },
+          },
+        ],
+      },
+      // Public API using alpha type
+      {
+        code: `
+/**
+ * An alpha interface.
+ * @alpha
+ */
+interface MyInterface {
+  name: string;
+}
+
+/**
+ * A public function.
+ * @public
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+        errors: [
+          {
+            messageId: 'incompatibleReleaseTags',
+            data: {
+              exportedName: 'myFunction',
+              exportedTag: '@public',
+              referencedName: 'MyInterface',
+              referencedTag: '@alpha',
+            },
+          },
+        ],
+      },
+      // Beta API using internal type
+      {
+        code: `
+/**
+ * An internal interface.
+ * @internal
+ */
+interface MyInterface {
+  name: string;
+}
+
+/**
+ * A beta function.
+ * @beta
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+        errors: [
+          {
+            messageId: 'incompatibleReleaseTags',
+            data: {
+              exportedName: 'myFunction',
+              exportedTag: '@beta',
+              referencedName: 'MyInterface',
+              referencedTag: '@internal',
+            },
+          },
+        ],
+      },
+      // Beta API using alpha type
+      {
+        code: `
+/**
+ * An alpha interface.
+ * @alpha
+ */
+interface MyInterface {
+  name: string;
+}
+
+/**
+ * A beta function.
+ * @beta
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+        errors: [
+          {
+            messageId: 'incompatibleReleaseTags',
+            data: {
+              exportedName: 'myFunction',
+              exportedTag: '@beta',
+              referencedName: 'MyInterface',
+              referencedTag: '@alpha',
+            },
+          },
+        ],
+      },
+      // Alpha API using internal type
+      {
+        code: `
+/**
+ * An internal interface.
+ * @internal
+ */
+interface MyInterface {
+  name: string;
+}
+
+/**
+ * An alpha function.
+ * @alpha
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+        errors: [
+          {
+            messageId: 'incompatibleReleaseTags',
+            data: {
+              exportedName: 'myFunction',
+              exportedTag: '@alpha',
+              referencedName: 'MyInterface',
+              referencedTag: '@internal',
+            },
+          },
+        ],
+      },
+      // Public interface with internal type property
+      {
+        code: `
+/**
+ * An internal type.
+ * @internal
+ */
+type InternalType = string;
+
+/**
+ * A public interface.
+ * @public
+ */
+export interface MyInterface {
+  value: InternalType;
+}
+`,
+        errors: [
+          {
+            messageId: 'incompatibleReleaseTags',
+            data: {
+              exportedName: 'MyInterface',
+              exportedTag: '@public',
+              referencedName: 'InternalType',
+              referencedTag: '@internal',
+            },
+          },
+        ],
+      },
+    ],
+  })
+
+  // Test with severity option
+  ruleTester.run(
+    'incompatible-release-tags with severity=none',
+    incompatibleReleaseTags,
+    {
+      valid: [
+        // Should not report when severity is 'none'
+        {
+          code: `
+/**
+ * An internal interface.
+ * @internal
+ */
+interface MyInterface {
+  name: string;
+}
+
+/**
+ * A public function.
+ * @public
+ */
+export function myFunction(param: MyInterface): void {}
+`,
+          options: [{ severity: 'none' }],
+        },
+      ],
+      invalid: [],
+    },
+  )
+})

package/test/rules/missing-release-tag.test.ts

@@ -1,5 +1,6 @@
 import { RuleTester } from '@typescript-eslint/rule-tester'
 import { describe, it, afterAll } from 'vitest'
+import * as tseslintParser from '@typescript-eslint/parser'
 import { missingReleaseTag } from '../../src/rules/missing-release-tag'
 
 RuleTester.afterAll = afterAll
@@ -8,7 +9,7 @@ RuleTester.it = it
 
 const ruleTester = new RuleTester({
   languageOptions: {
-    parser: require('@typescript-eslint/parser'),
+    parser: tseslintParser,
     parserOptions: {
       ecmaVersion: 2022,
       sourceType: 'module',

package/test/rules/override-keyword.test.ts

@@ -1,5 +1,6 @@
 import { RuleTester } from '@typescript-eslint/rule-tester'
 import { describe, it, afterAll } from 'vitest'
+import * as tseslintParser from '@typescript-eslint/parser'
 import { overrideKeyword } from '../../src/rules/override-keyword'
 
 RuleTester.afterAll = afterAll
@@ -8,7 +9,7 @@ RuleTester.it = it
 
 const ruleTester = new RuleTester({
   languageOptions: {
-    parser: require('@typescript-eslint/parser'),
+    parser: tseslintParser,
     parserOptions: {
       ecmaVersion: 2022,
       sourceType: 'module',

package/test/rules/package-documentation.test.ts

@@ -2,13 +2,15 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import * as path from 'path'
 import * as fs from 'fs'
 import * as os from 'os'
-import { clearPackageJsonCache } from '../../src/utils/entry-point.js'
 import {
   findPackageJson,
   isEntryPoint,
+  clearPackageJsonCache,
+} from '../../src/utils/entry-point.js'
+import {
   hasPackageDocumentation,
   parseTSDocComment,
-} from '../../src/utils'
+} from '../../src/utils/tsdoc-parser.js'
 
 describe('package-documentation', () => {
   let tempDir: string
@@ -72,7 +74,7 @@ describe('package-documentation', () => {
  */`
       const parsed = parseTSDocComment(comment)
       expect(parsed.docComment).toBeDefined()
-      expect(hasPackageDocumentation(parsed.docComment!)).toBe(true)
+      expect(hasPackageDocumentation(parsed.docComment)).toBe(true)
     })
 
     it('should return false when @packageDocumentation is missing', () => {
@@ -81,7 +83,7 @@ describe('package-documentation', () => {
  */`
       const parsed = parseTSDocComment(comment)
       expect(parsed.docComment).toBeDefined()
-      expect(hasPackageDocumentation(parsed.docComment!)).toBe(false)
+      expect(hasPackageDocumentation(parsed.docComment)).toBe(false)
     })
   })
 
@@ -108,7 +110,7 @@ export function foo() {}`
  * This is the main entry point.
  * @packageDocumentation
  */`)
-      expect(hasPackageDocumentation(parsed.docComment!)).toBe(true)
+      expect(hasPackageDocumentation(parsed.docComment)).toBe(true)
     })
 
     it('should fail when entry point lacks @packageDocumentation', () => {
@@ -131,7 +133,7 @@ export function foo() {}`
       const parsed = parseTSDocComment(`/**
  * This is the main entry point.
  */`)
-      expect(hasPackageDocumentation(parsed.docComment!)).toBe(false)
+      expect(hasPackageDocumentation(parsed.docComment)).toBe(false)
     })
 
     it('should not require @packageDocumentation for non-entry points', () => {

package/test/rules/public-on-non-exported.test.ts

@@ -0,0 +1,201 @@
+import { RuleTester } from '@typescript-eslint/rule-tester'
+import { describe, it, afterAll } from 'vitest'
+import * as tseslintParser from '@typescript-eslint/parser'
+import { publicOnNonExported } from '../../src/rules/public-on-non-exported'
+
+RuleTester.afterAll = afterAll
+RuleTester.describe = describe
+RuleTester.it = it
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parser: tseslintParser,
+    parserOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+    },
+  },
+})
+
+describe('public-on-non-exported', () => {
+  ruleTester.run('public-on-non-exported', publicOnNonExported, {
+    valid: [
+      // Exported function with @public tag
+      {
+        code: `
+/**
+ * A public function.
+ * @public
+ */
+export function myFunction(): void {}
+`,
+      },
+      // Exported class with @public tag
+      {
+        code: `
+/**
+ * A public class.
+ * @public
+ */
+export class MyClass {}
+`,
+      },
+      // Exported interface with @public tag
+      {
+        code: `
+/**
+ * A public interface.
+ * @public
+ */
+export interface MyInterface {}
+`,
+      },
+      // Exported type with @public tag
+      {
+        code: `
+/**
+ * A public type.
+ * @public
+ */
+export type MyType = string;
+`,
+      },
+      // Exported via export statement
+      {
+        code: `
+/**
+ * A public function.
+ * @public
+ */
+function myFunction(): void {}
+
+export { myFunction };
+`,
+      },
+      // Non-exported function without @public tag
+      {
+        code: `
+/**
+ * An internal function.
+ * @internal
+ */
+function myFunction(): void {}
+`,
+      },
+    ],
+    invalid: [
+      // Non-exported function with @public tag
+      {
+        code: `
+/**
+ * A public function.
+ * @public
+ */
+function myFunction(): void {}
+`,
+        errors: [
+          {
+            messageId: 'publicOnNonExported',
+            data: {
+              name: 'myFunction',
+            },
+          },
+        ],
+      },
+      // Non-exported class with @public tag
+      {
+        code: `
+/**
+ * A public class.
+ * @public
+ */
+class MyClass {}
+`,
+        errors: [
+          {
+            messageId: 'publicOnNonExported',
+            data: {
+              name: 'MyClass',
+            },
+          },
+        ],
+      },
+      // Non-exported interface with @public tag
+      {
+        code: `
+/**
+ * A public interface.
+ * @public
+ */
+interface MyInterface {}
+`,
+        errors: [
+          {
+            messageId: 'publicOnNonExported',
+            data: {
+              name: 'MyInterface',
+            },
+          },
+        ],
+      },
+      // Non-exported type with @public tag
+      {
+        code: `
+/**
+ * A public type.
+ * @public
+ */
+type MyType = string;
+`,
+        errors: [
+          {
+            messageId: 'publicOnNonExported',
+            data: {
+              name: 'MyType',
+            },
+          },
+        ],
+      },
+      // Non-exported enum with @public tag
+      {
+        code: `
+/**
+ * A public enum.
+ * @public
+ */
+enum MyEnum { A, B }
+`,
+        errors: [
+          {
+            messageId: 'publicOnNonExported',
+            data: {
+              name: 'MyEnum',
+            },
+          },
+        ],
+      },
+    ],
+  })
+
+  // Test with severity option
+  ruleTester.run(
+    'public-on-non-exported with severity=none',
+    publicOnNonExported,
+    {
+      valid: [
+        // Should not report when severity is 'none'
+        {
+          code: `
+/**
+ * A public function.
+ * @public
+ */
+function myFunction(): void {}
+`,
+          options: [{ severity: 'none' }],
+        },
+      ],
+      invalid: [],
+    },
+  )
+})