17481381036

Committed 05 Sep 2025 01:51AM UTC coverage: 98.639% (+0.7%) from 97.96%

Build # 17481381036

Build Type

push

github

Committed by

brettz9

Commit Message

feat: add ESM export; fixes #173

BREAKING CHANGE:

Adds `exports`

Run Details

777 of 788 branches covered (98.6%)

Branch coverage included in aggregate %.

4005 of 4060 relevant lines covered (98.65%)

1434.64 hits per line

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

95.52

/src/transforms/identityTransformRules.ts

import { type TransformRules } from './transform'
import {
  type JsdocObjectFieldResult,
  type KeyValueResult,
  type NonRootResult,
  type ObjectFieldResult
} from '../result/NonRootResult'
import {
  type FunctionResult,
  type NameResult,
  type StringValueResult,
  type SymbolResult,
  type RootResult,
  type VariadicResult,
  type 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) => {
      return {
        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 {	1✔
3	type JsdocObjectFieldResult,	1✔
4	type KeyValueResult,	1✔
5	type NonRootResult,	1✔
6	type ObjectFieldResult	1✔
7	} from '../result/NonRootResult'	1✔
8	import {	1✔
9	type FunctionResult,	1✔
10	type NameResult,	1✔
11	type StringValueResult,	1✔
12	type SymbolResult,	1✔
13	type RootResult,	1✔
14	type VariadicResult,	1✔
15	type 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	return {	64✔
109	type: 'JsdocTypeKeyValue',	64✔
110	key: result.key,	64✔
111	right: result.right === undefined ? undefined : transform(result.right) as RootResult,	64!
112	optional: result.optional,	64✔
113	variadic: result.variadic	64✔
114	}	64✔
115	},	5✔
116		5✔
117	JsdocTypeImport: (result, transform) => ({	5✔
118	type: 'JsdocTypeImport',	6✔
119	element: transform(result.element) as StringValueResult	6✔
120	}),	5✔
121		5✔
122	JsdocTypeAny: result => result,	5✔
123		5✔
124	JsdocTypeStringValue: result => result,	5✔
125		5✔
126	JsdocTypeNamePath: result => result,	5✔
127		5✔
128	JsdocTypeVariadic: (result, transform) => {	5✔
129	const transformed: VariadicResult<RootResult> = {	71✔
130	type: 'JsdocTypeVariadic',	71✔
131	meta: {	71✔
132	position: result.meta.position,	71✔
133	squareBrackets: result.meta.squareBrackets	71✔
134	}	71✔
135	}	71✔
136		71✔
137	if (result.element !== undefined) {	71✔
138	transformed.element = transform(result.element) as RootResult	68✔
139	}	68✔
140		71✔
141	return transformed	71✔
142	},	5✔
143		5✔
144	JsdocTypeTuple: (result, transform) => ({	5✔
145	type: 'JsdocTypeTuple',	36✔
146	elements: (result.elements as NonRootResult[]).map(transform) as RootResult[] \| KeyValueResult[]	36✔
147	}),	5✔
148		5✔
149	JsdocTypeName: result => result,	5✔
150		5✔
151	JsdocTypeFunction: (result, transform) => {	5✔
152	const transformed: FunctionResult = {	132✔
153	type: 'JsdocTypeFunction',	132✔
154	arrow: result.arrow,	132✔
155	parameters: result.parameters.map(transform) as RootResult[],	132✔
156	constructor: result.constructor,	132✔
157	parenthesis: result.parenthesis	132✔
158	}	132✔
159		132✔
160	if (result.returnType !== undefined) {	132✔
161	transformed.returnType = transform(result.returnType) as RootResult	96✔
162	}	96✔
163		132✔
164	return transformed	132✔
165	},	5✔
166		5✔
167	JsdocTypeKeyof: (result, transform) => ({	5✔
168	type: 'JsdocTypeKeyof',	30✔
169	element: transform(result.element) as RootResult	30✔
170	}),	5✔
171		5✔
172	JsdocTypeParenthesis: (result, transform) => ({	5✔
173	type: 'JsdocTypeParenthesis',	1✔
174	element: transform(result.element) as RootResult	1✔
175	}),	5✔
176		5✔
177	JsdocTypeProperty: result => result,	5✔
178		5✔
179	JsdocTypePredicate: (result, transform) => ({	5✔
180	type: 'JsdocTypePredicate',	2✔
181	left: transform(result.left) as NameResult,	2✔
182	right: transform(result.right) as RootResult	2✔
183	}),	5✔
184		5✔
185	JsdocTypeIndexSignature: (result, transform) => ({	5✔
186	type: 'JsdocTypeIndexSignature',	×
187	key: result.key,	×
188	right: transform(result.right) as RootResult	×
189	}),	5✔
190		5✔
191	JsdocTypeMappedType: (result, transform) => ({	5✔
192	type: 'JsdocTypeMappedType',	×
193	key: result.key,	×
194	right: transform(result.right) as RootResult	×
195	}),	5✔
196		5✔
197	JsdocTypeAsserts: (result, transform) => ({	5✔
198	type: 'JsdocTypeAsserts',	2✔
199	left: transform(result.left) as NameResult,	2✔
200	right: transform(result.right) as RootResult	2✔
201	}),	5✔
202		5✔
203	JsdocTypeReadonlyArray: (result, transform) => ({	5✔
204	type: 'JsdocTypeReadonlyArray',	4✔
205	element: transform(result.element) as RootResult	4✔
206	}),	5✔
207		5✔
208	JsdocTypeAssertsPlain: (result, transform) => ({	5✔
209	type: 'JsdocTypeAssertsPlain',	2✔
210	element: transform(result.element) as NameResult	2✔
211	}),	5✔
212		5✔
213	JsdocTypeConditional: (result, transform) => ({	5✔
214	type: 'JsdocTypeConditional',	4✔
215	checksType: transform(result.checksType) as RootResult,	4✔
216	extendsType: transform(result.extendsType) as RootResult,	4✔
217	trueType: transform(result.trueType) as RootResult,	4✔
218	falseType: transform(result.falseType) as RootResult	4✔
219	}),	5✔
220		5✔
221	JsdocTypeTypeParameter: (result, transform) => ({	5✔
222	type: 'JsdocTypeTypeParameter',	×
223	name: transform(result.name) as NameResult,	×
224	constraint: result.constraint !== undefined ? transform(result.constraint) as RootResult : undefined,	×
225	defaultValue: result.defaultValue !== undefined ? transform(result.defaultValue) as RootResult : undefined	×
226	})	×
227	}	5✔
228	}	5✔

jsdoc-type-pratt-parser / jsdoc-type-pratt-parser / 17481381036

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