17509961174

Committed 06 Sep 2025 04:26AM UTC coverage: 98.559% (-0.08%) from 98.639%

Build # 17509961174

Build Type

push

github

Committed by

brettz9

Commit Message

feat(typescript): allow missing return type; fixes #81

Run Details

778 of 789 branches covered (98.61%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

7 existing lines in 2 files now uncovered.

3599 of 3652 relevant lines covered (98.55%)

1636.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.49

/src/transforms/identityTransformRules.ts

import type { TransformRules } from './transform'
import type {
  JsdocObjectFieldResult,
  KeyValueResult,
  NonRootResult,
  ObjectFieldResult
} from '../result/NonRootResult'
import type {
  FunctionResult,
  NameResult,
  StringValueResult,
  SymbolResult,
  RootResult,
  VariadicResult,
  NumberResult
} from '../result/RootResult'

export function identityTransformRules (): TransformRules<NonRootResult> {
  return {
    JsdocTypeIntersection: (result, transform) => ({
      type: 'JsdocTypeIntersection',
      elements: result.elements.map(transform) as RootResult[]
    }),

    JsdocTypeGeneric: (result, transform) => ({
      type: 'JsdocTypeGeneric',
      left: transform(result.left) as RootResult,
      elements: result.elements.map(transform) as RootResult[],
      meta: {
        dot: result.meta.dot,
        brackets: result.meta.brackets
      }
    }),

    JsdocTypeNullable: result => result,

    JsdocTypeUnion: (result, transform) => ({
      type: 'JsdocTypeUnion',
      elements: result.elements.map(transform) as RootResult[]
    }),

    JsdocTypeUnknown: result => result,

    JsdocTypeUndefined: result => result,

    JsdocTypeTypeof: (result, transform) => ({
      type: 'JsdocTypeTypeof',
      element: transform(result.element) as RootResult
    }),

    JsdocTypeSymbol: (result, transform) => {
      const transformed: SymbolResult = {
        type: 'JsdocTypeSymbol',
        value: result.value
      }
      if (result.element !== undefined) {
        transformed.element = transform(result.element) as NumberResult | NameResult | VariadicResult<NameResult>
      }
      return transformed
    },

    JsdocTypeOptional: (result, transform) => ({
      type: 'JsdocTypeOptional',
      element: transform(result.element) as RootResult,
      meta: {
        position: result.meta.position
      }
    }),

    JsdocTypeObject: (result, transform) => ({
      type: 'JsdocTypeObject',
      meta: {
        separator: 'comma'
      },
      elements: result.elements.map(transform) as Array<ObjectFieldResult | JsdocObjectFieldResult>
    }),

    JsdocTypeNumber: result => result,

    JsdocTypeNull: result => result,

    JsdocTypeNotNullable: (result, transform) => ({
      type: 'JsdocTypeNotNullable',
      element: transform(result.element) as RootResult,
      meta: {
        position: result.meta.position
      }
    }),

    JsdocTypeSpecialNamePath: result => result,

    JsdocTypeObjectField: (result, transform) => ({
      type: 'JsdocTypeObjectField',
      key: result.key,
      right: result.right === undefined ? undefined : transform(result.right) as RootResult,
      optional: result.optional,
      readonly: result.readonly,
      meta: result.meta
    }),

    JsdocTypeJsdocObjectField: (result, transform) => ({
      type: 'JsdocTypeJsdocObjectField',
      left: transform(result.left) as RootResult,
      right: transform(result.right) as RootResult
    }),

    JsdocTypeKeyValue: (result, transform) => ({
      type: 'JsdocTypeKeyValue',
      key: result.key,
      right: result.right === undefined ? undefined : transform(result.right) as RootResult,
      optional: result.optional,
      variadic: result.variadic
    }),

    JsdocTypeImport: (result, transform) => ({
      type: 'JsdocTypeImport',
      element: transform(result.element) as StringValueResult
    }),

    JsdocTypeAny: result => result,

    JsdocTypeStringValue: result => result,

    JsdocTypeNamePath: result => result,

    JsdocTypeVariadic: (result, transform) => {
      const transformed: VariadicResult<RootResult> = {
        type: 'JsdocTypeVariadic',
        meta: {
          position: result.meta.position,
          squareBrackets: result.meta.squareBrackets
        }
      }

      if (result.element !== undefined) {
        transformed.element = transform(result.element) as RootResult
      }

      return transformed
    },

    JsdocTypeTuple: (result, transform) => ({
      type: 'JsdocTypeTuple',
      elements: (result.elements as NonRootResult[]).map(transform) as RootResult[] | KeyValueResult[]
    }),

    JsdocTypeName: result => result,

    JsdocTypeFunction: (result, transform) => {
      const transformed: FunctionResult = {
        type: 'JsdocTypeFunction',
        arrow: result.arrow,
        parameters: result.parameters.map(transform) as RootResult[],
        constructor: result.constructor,
        parenthesis: result.parenthesis
      }

      if (result.returnType !== undefined) {
        transformed.returnType = transform(result.returnType) as RootResult
      }

      return transformed
    },

    JsdocTypeKeyof: (result, transform) => ({
      type: 'JsdocTypeKeyof',
      element: transform(result.element) as RootResult
    }),

    JsdocTypeParenthesis: (result, transform) => ({
      type: 'JsdocTypeParenthesis',
      element: transform(result.element) as RootResult
    }),

    JsdocTypeProperty: result => result,

    JsdocTypePredicate: (result, transform) => ({
      type: 'JsdocTypePredicate',
      left: transform(result.left) as NameResult,
      right: transform(result.right) as RootResult
    }),

    JsdocTypeIndexSignature: (result, transform) => ({
      type: 'JsdocTypeIndexSignature',
      key: result.key,
      right: transform(result.right) as RootResult
    }),

    JsdocTypeMappedType: (result, transform) => ({
      type: 'JsdocTypeMappedType',
      key: result.key,
      right: transform(result.right) as RootResult
    }),

    JsdocTypeAsserts: (result, transform) => ({
      type: 'JsdocTypeAsserts',
      left: transform(result.left) as NameResult,
      right: transform(result.right) as RootResult
    }),

    JsdocTypeReadonlyArray: (result, transform) => ({
      type: 'JsdocTypeReadonlyArray',
      element: transform(result.element) as RootResult
    }),

    JsdocTypeAssertsPlain: (result, transform) => ({
      type: 'JsdocTypeAssertsPlain',
      element: transform(result.element) as NameResult
    }),

    JsdocTypeConditional: (result, transform) => ({
      type: 'JsdocTypeConditional',
      checksType: transform(result.checksType) as RootResult,
      extendsType: transform(result.extendsType) as RootResult,
      trueType: transform(result.trueType) as RootResult,
      falseType: transform(result.falseType) as RootResult
    }),

    JsdocTypeTypeParameter: (result, transform) => ({
      type: 'JsdocTypeTypeParameter',
      name: transform(result.name) as NameResult,
      constraint: result.constraint !== undefined ? transform(result.constraint) as RootResult : undefined,
      defaultValue: result.defaultValue !== undefined ? transform(result.defaultValue) as RootResult : undefined
    })
  }
}

1	import type { TransformRules } from './transform'	1✔
2	import type {	1✔
3	JsdocObjectFieldResult,	1✔
4	KeyValueResult,	1✔
5	NonRootResult,	1✔
6	ObjectFieldResult	1✔
7	} from '../result/NonRootResult'	1✔
8	import type {	1✔
9	FunctionResult,	1✔
10	NameResult,	1✔
11	StringValueResult,	1✔
12	SymbolResult,	1✔
13	RootResult,	1✔
14	VariadicResult,	1✔
15	NumberResult	1✔
16	} from '../result/RootResult'	1✔
17		1✔
18	export function identityTransformRules (): TransformRules<NonRootResult> {	1✔
19	return {	5✔
20	JsdocTypeIntersection: (result, transform) => ({	5✔
21	type: 'JsdocTypeIntersection',	8✔
22	elements: result.elements.map(transform) as RootResult[]	8✔
23	}),	5✔
24		5✔
25	JsdocTypeGeneric: (result, transform) => ({	5✔
26	type: 'JsdocTypeGeneric',	84✔
27	left: transform(result.left) as RootResult,	84✔
28	elements: result.elements.map(transform) as RootResult[],	84✔
29	meta: {	84✔
30	dot: result.meta.dot,	84✔
31	brackets: result.meta.brackets	84✔
32	}	84✔
33	}),	5✔
34		5✔
35	JsdocTypeNullable: result => result,	5✔
36		5✔
37	JsdocTypeUnion: (result, transform) => ({	5✔
38	type: 'JsdocTypeUnion',	66✔
39	elements: result.elements.map(transform) as RootResult[]	66✔
40	}),	5✔
41		5✔
42	JsdocTypeUnknown: result => result,	5✔
43		5✔
44	JsdocTypeUndefined: result => result,	5✔
45		5✔
46	JsdocTypeTypeof: (result, transform) => ({	5✔
47	type: 'JsdocTypeTypeof',	32✔
48	element: transform(result.element) as RootResult	32✔
49	}),	5✔
50		5✔
51	JsdocTypeSymbol: (result, transform) => {	5✔
52	const transformed: SymbolResult = {	12✔
53	type: 'JsdocTypeSymbol',	12✔
54	value: result.value	12✔
55	}	12✔
56	if (result.element !== undefined) {	12✔
57	transformed.element = transform(result.element) as NumberResult \| NameResult \| VariadicResult<NameResult>	10✔
58	}	10✔
59	return transformed	12✔
60	},	5✔
61		5✔
62	JsdocTypeOptional: (result, transform) => ({	5✔
63	type: 'JsdocTypeOptional',	32✔
64	element: transform(result.element) as RootResult,	32✔
65	meta: {	32✔
66	position: result.meta.position	32✔
67	}	32✔
68	}),	5✔
69		5✔
70	JsdocTypeObject: (result, transform) => ({	5✔
71	type: 'JsdocTypeObject',	80✔
72	meta: {	80✔
73	separator: 'comma'	80✔
74	},	80✔
75	elements: result.elements.map(transform) as Array<ObjectFieldResult \| JsdocObjectFieldResult>	80✔
76	}),	5✔
77		5✔
78	JsdocTypeNumber: result => result,	5✔
79		5✔
80	JsdocTypeNull: result => result,	5✔
81		5✔
82	JsdocTypeNotNullable: (result, transform) => ({	5✔
83	type: 'JsdocTypeNotNullable',	24✔
84	element: transform(result.element) as RootResult,	24✔
85	meta: {	24✔
86	position: result.meta.position	24✔
87	}	24✔
88	}),	5✔
89		5✔
90	JsdocTypeSpecialNamePath: result => result,	5✔
91		5✔
92	JsdocTypeObjectField: (result, transform) => ({	5✔
93	type: 'JsdocTypeObjectField',	82✔
94	key: result.key,	82✔
95	right: result.right === undefined ? undefined : transform(result.right) as RootResult,	82✔
96	optional: result.optional,	82✔
97	readonly: result.readonly,	82✔
98	meta: result.meta	82✔
99	}),	5✔
100		5✔
101	JsdocTypeJsdocObjectField: (result, transform) => ({	5✔
102	type: 'JsdocTypeJsdocObjectField',	6✔
103	left: transform(result.left) as RootResult,	6✔
104	right: transform(result.right) as RootResult	6✔
105	}),	5✔
106		5✔
107	JsdocTypeKeyValue: (result, transform) => ({	5✔
108	type: 'JsdocTypeKeyValue',	64✔
109	key: result.key,	64✔
110	right: result.right === undefined ? undefined : transform(result.right) as RootResult,	64!
111	optional: result.optional,	64✔
112	variadic: result.variadic	64✔
113	}),	5✔
114		5✔
115	JsdocTypeImport: (result, transform) => ({	5✔
116	type: 'JsdocTypeImport',	6✔
117	element: transform(result.element) as StringValueResult	6✔
118	}),	5✔
119		5✔
120	JsdocTypeAny: result => result,	5✔
121		5✔
122	JsdocTypeStringValue: result => result,	5✔
123		5✔
124	JsdocTypeNamePath: result => result,	5✔
125		5✔
126	JsdocTypeVariadic: (result, transform) => {	5✔
127	const transformed: VariadicResult<RootResult> = {	71✔
128	type: 'JsdocTypeVariadic',	71✔
129	meta: {	71✔
130	position: result.meta.position,	71✔
131	squareBrackets: result.meta.squareBrackets	71✔
132	}	71✔
133	}	71✔
134		71✔
135	if (result.element !== undefined) {	71✔
136	transformed.element = transform(result.element) as RootResult	68✔
137	}	68✔
138		71✔
139	return transformed	71✔
140	},	5✔
141		5✔
142	JsdocTypeTuple: (result, transform) => ({	5✔
143	type: 'JsdocTypeTuple',	36✔
144	elements: (result.elements as NonRootResult[]).map(transform) as RootResult[] \| KeyValueResult[]	36✔
145	}),	5✔
146		5✔
147	JsdocTypeName: result => result,	5✔
148		5✔
149	JsdocTypeFunction: (result, transform) => {	5✔
150	const transformed: FunctionResult = {	134✔
151	type: 'JsdocTypeFunction',	134✔
152	arrow: result.arrow,	134✔
153	parameters: result.parameters.map(transform) as RootResult[],	134✔
154	constructor: result.constructor,	134✔
155	parenthesis: result.parenthesis	134✔
156	}	134✔
157		134✔
158	if (result.returnType !== undefined) {	134✔
159	transformed.returnType = transform(result.returnType) as RootResult	96✔
160	}	96✔
161		134✔
162	return transformed	134✔
163	},	5✔
164		5✔
165	JsdocTypeKeyof: (result, transform) => ({	5✔
166	type: 'JsdocTypeKeyof',	32✔
167	element: transform(result.element) as RootResult	32✔
168	}),	5✔
169		5✔
170	JsdocTypeParenthesis: (result, transform) => ({	5✔
171	type: 'JsdocTypeParenthesis',	1✔
172	element: transform(result.element) as RootResult	1✔
173	}),	5✔
174		5✔
175	JsdocTypeProperty: result => result,	5✔
176		5✔
177	JsdocTypePredicate: (result, transform) => ({	5✔
178	type: 'JsdocTypePredicate',	2✔
179	left: transform(result.left) as NameResult,	2✔
180	right: transform(result.right) as RootResult	2✔
181	}),	5✔
182		5✔
183	JsdocTypeIndexSignature: (result, transform) => ({	5✔
UNCOV 184	type: 'JsdocTypeIndexSignature',	×
UNCOV 185	key: result.key,	×
186	right: transform(result.right) as RootResult	×
187	}),	5✔
188		5✔
189	JsdocTypeMappedType: (result, transform) => ({	5✔
UNCOV 190	type: 'JsdocTypeMappedType',	×
UNCOV 191	key: result.key,	×
192	right: transform(result.right) as RootResult	×
193	}),	5✔
194		5✔
195	JsdocTypeAsserts: (result, transform) => ({	5✔
196	type: 'JsdocTypeAsserts',	2✔
197	left: transform(result.left) as NameResult,	2✔
198	right: transform(result.right) as RootResult	2✔
199	}),	5✔
200		5✔
201	JsdocTypeReadonlyArray: (result, transform) => ({	5✔
202	type: 'JsdocTypeReadonlyArray',	4✔
203	element: transform(result.element) as RootResult	4✔
204	}),	5✔
205		5✔
206	JsdocTypeAssertsPlain: (result, transform) => ({	5✔
207	type: 'JsdocTypeAssertsPlain',	2✔
208	element: transform(result.element) as NameResult	2✔
209	}),	5✔
210		5✔
211	JsdocTypeConditional: (result, transform) => ({	5✔
212	type: 'JsdocTypeConditional',	4✔
213	checksType: transform(result.checksType) as RootResult,	4✔
214	extendsType: transform(result.extendsType) as RootResult,	4✔
215	trueType: transform(result.trueType) as RootResult,	4✔
216	falseType: transform(result.falseType) as RootResult	4✔
217	}),	5✔
218		5✔
219	JsdocTypeTypeParameter: (result, transform) => ({	5✔
UNCOV 220	type: 'JsdocTypeTypeParameter',	×
UNCOV 221	name: transform(result.name) as NameResult,	×
222	constraint: result.constraint !== undefined ? transform(result.constraint) as RootResult : undefined,	×
223	defaultValue: result.defaultValue !== undefined ? transform(result.defaultValue) as RootResult : undefined	×
224	})	×
225	}	5✔
226	}	5✔

jsdoc-type-pratt-parser / jsdoc-type-pratt-parser / 17509961174

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous