feat(nodes): InferType

Signed-off-by: Lexus Drumgold <[email protected]>

.eslintrc.base.cjs

@@ -34,7 +34,7 @@ const config = {
       parser: '@typescript-eslint/parser',
       parserOptions: {
         extraFileExtensions: [],
-        project: ['**/tsconfig.json', '**/tsconfig.*.json'],
+        project: ['./tsconfig.json', './tsconfig.typecheck.json'],
         tsconfigRootDir: process.cwd(),
         warnOnUnsupportedTypeScriptVersion: true
       },

.vscode/settings.json

@@ -80,9 +80,9 @@
   "editor.bracketPairColorization.enabled": true,
   "editor.bracketPairColorization.independentColorPoolPerBracketType": true,
   "editor.codeActionsOnSave": {
-    "source.fixAll": "always",
+    "source.fixAll.eslint": "explicit",
     "source.fixAll.sortJSON": "never",
-    "source.organizeImports": "always"
+    "source.organizeImports": "explicit"
   },
   "editor.defaultFormatter": "dprint.dprint",
   "editor.detectIndentation": false,
@@ -137,6 +137,7 @@
     "overrideConfigFile": ".eslintrc.cjs"
   },
   "eslint.runtime": "node",
+  "eslint.trace.server": "messages",
   "eslint.validate": [
     "css",
     "github-actions-workflow",
@@ -309,6 +310,11 @@
       "format": "svg",
       "icon": "private"
     },
+    {
+      "extensions": ["namespaces"],
+      "format": "svg",
+      "icon": "module"
+    },
     {
       "extensions": ["patches"],
       "format": "svg",

src/content/__tests__/expression-type.spec-d.ts

@@ -12,6 +12,7 @@ import type {
   GenericType,
   Identifier,
   IndexedAccessType,
+  InferType,
   IntersectionType,
   MappedType,
   ObjectLiteralType,
@@ -81,6 +82,11 @@ describe('unit-d:content/typeExpression', () => {
         .toMatchTypeOf<NodeObject<IndexedAccessType>>()
     })
 
+    it('should match NodeObject<InferType>', () => {
+      expectTypeOf<TestSubject.TypeExpressionMap>()
+        .toMatchTypeOf<NodeObject<InferType>>()
+    })
+
     it('should match NodeObject<IntersectionType>', () => {
       expectTypeOf<TestSubject.TypeExpressionMap>()
         .toMatchTypeOf<NodeObject<IntersectionType>>()

src/content/expression-type.ts

@@ -11,6 +11,7 @@ import type {
   GenericType,
   Identifier,
   IndexedAccessType,
+  InferType,
   IntersectionType,
   MappedType,
   ObjectLiteralType,
@@ -58,6 +59,7 @@ interface TypeExpressionMap extends PrimitiveMap {
   genericType: GenericType
   identifier: Identifier
   indexedAccessType: IndexedAccessType
+  inferType: InferType
   intersectionType: IntersectionType
   mappedType: MappedType
   objectLiteralType: ObjectLiteralType

src/nodes/__tests__/type-infer.spec-d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file Type Tests - InferType
+ * @module esast/nodes/tests/unit-d/InferType
+ */
+
+import type { Data, Parent } from '@flex-development/esast'
+import type { Optional } from '@flex-development/tutils'
+import type * as TestSubject from '../type-infer'
+
+describe('unit-d:nodes/InferType', () => {
+  type Subject = TestSubject.default
+  type SubjectData = TestSubject.InferTypeData
+
+  it('should extend Parent', () => {
+    expectTypeOf<Subject>().toMatchTypeOf<Parent>()
+  })
+
+  it('should match [data?: Optional<InferTypeData>]', () => {
+    expectTypeOf<Subject>()
+      .toHaveProperty('data')
+      .toEqualTypeOf<Optional<SubjectData>>()
+  })
+
+  it('should match [type: "inferType"]', () => {
+    expectTypeOf<Subject>()
+      .toHaveProperty('type')
+      .toEqualTypeOf<'inferType'>()
+  })
+
+  describe('InferTypeData', () => {
+    it('should extend Data', () => {
+      expectTypeOf<SubjectData>().toMatchTypeOf<Data>()
+    })
+  })
+})

src/nodes/index.ts

@@ -415,6 +415,7 @@ export type {
   default as IndexedAccessType,
   IndexedAccessTypeData
 } from './type-indexed-access'
+export type { default as InferType, InferTypeData } from './type-infer'
 export type {
   default as IntersectionType,
   IntersectionTypeData

src/nodes/type-infer.ts

@@ -0,0 +1,63 @@
+/**
+ * @file Nodes - InferType
+ * @module esast/nodes/InferType
+ */
+
+import type { InternalComments } from '#internal'
+import type {
+  Comments,
+  Data,
+  ExtendsClause,
+  Identifier,
+  Parent
+} from '@flex-development/esast'
+import type { Optional } from '@flex-development/tutils'
+
+/**
+ * Info associated with `infer` types.
+ *
+ * @see {@linkcode Data}
+ *
+ * @extends {Data}
+ */
+interface InferTypeData extends Data {}
+
+/**
+ * An `infer` type.
+ *
+ * @see {@linkcode Parent}
+ * @see https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#inferring-within-conditional-types
+ *
+ * @extends {Parent}
+ */
+interface InferType extends Parent {
+  /**
+   * List of children.
+   *
+   * @see {@linkcode Comments}
+   * @see {@linkcode ExtendsClause}
+   * @see {@linkcode Identifier}
+   */
+  children:
+    | [
+      ...comments: Comments,
+      identifier: Identifier,
+      ...comments: InternalComments,
+      extend: ExtendsClause
+    ]
+    | [...comments: Comments, identifier: Identifier]
+
+  /**
+   * Info from the ecosystem.
+   *
+   * @see {@linkcode InferTypeData}
+   */
+  data?: Optional<InferTypeData>
+
+  /**
+   * Node type.
+   */
+  type: 'inferType'
+}
+
+export type { InferTypeData, InferType as default }

src/types/__tests__/operator-unary-type.spec-d.ts

@@ -10,10 +10,6 @@ describe('unit-d:types/UnaryTypeOperator', () => {
     expectTypeOf<TestSubject>().extract<'asserts'>().not.toBeNever()
   })
 
-  it('should extract "infer"', () => {
-    expectTypeOf<TestSubject>().extract<'infer'>().not.toBeNever()
-  })
-
   it('should extract "keyof"', () => {
     expectTypeOf<TestSubject>().extract<'keyof'>().not.toBeNever()
   })

src/types/operator-unary-type.ts

@@ -8,11 +8,10 @@
  *
  * A unary operation is an operation with only one operand.
  *
- * @see https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#inferring-within-conditional-types
  * @see https://www.typescriptlang.org/docs/handbook/2/keyof-types.html
  * @see https://www.typescriptlang.org/docs/handbook/2/typeof-types.html
  * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions
  */
-type UnaryTypeOperator = 'asserts' | 'infer' | 'keyof' | 'readonly' | 'typeof'
+type UnaryTypeOperator = 'asserts' | 'keyof' | 'readonly' | 'typeof'
 
 export type { UnaryTypeOperator as default }

tsconfig.json

@@ -60,10 +60,10 @@
     "__tests__/setup/index.d.mts"
   ],
   "include": [
-    "**/**/*.json",
-    "**/**/*.mjs",
-    "**/**/*.mts",
-    "**/**/*.ts",
+    "**/*.json",
+    "**/*.mjs",
+    "**/*.mts",
+    "**/*.ts",
     "**/.*.json",
     "**/.*.mjs",
     "**/.*.mts",