10248134822

Committed 05 Aug 2024 09:15AM UTC coverage: 98.173%. Remained the same

Build # 10248134822

Build Type

push

github

Committed by

simonseyock

Commit Message

ci: fix github token usage

Run Details

541 of 556 branches covered (97.3%)

Branch coverage included in aggregate %.

1125 of 1141 relevant lines covered (98.6%)

2627.22 hits per line

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

94.34

/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
    })
  }
}

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

jsdoc-type-pratt-parser / jsdoc-type-pratt-parser / 10248134822

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