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

98.54

/src/transforms/stringify.ts

import { transform, type TransformRules } from './transform'
import { type NonRootResult } from '../result/NonRootResult'
import { type RootResult } from '../result/RootResult'

function applyPosition (position: 'prefix' | 'suffix', target: string, value: string): string {
  return position === 'prefix' ? value + target : target + value
}

export function quote (value: string, quote: 'single' | 'double' | undefined): string {
  switch (quote) {
    case 'double':
      return `"${value}"`
    case 'single':
      return `'${value}'`
    case undefined:
      return value
  }
}

export function stringifyRules (): TransformRules<string> {
  return {
    JsdocTypeParenthesis: (result, transform) => `(${result.element !== undefined ? transform(result.element) : ''})`,

    JsdocTypeKeyof: (result, transform) => `keyof ${transform(result.element)}`,

    JsdocTypeFunction: (result, transform) => {
      if (!result.arrow) {
        let stringified = result.constructor ? 'new' : 'function'
        if (!result.parenthesis) {
          return stringified
        }
        stringified += `(${result.parameters.map(transform).join(', ')})`
        if (result.returnType !== undefined) {
          stringified += `: ${transform(result.returnType)}`
        }
        return stringified
      } else {
        if (result.returnType === undefined) {
          throw new Error('Arrow function needs a return type.')
        }
        let stringified = `(${result.parameters.map(transform).join(', ')}) => ${transform(result.returnType)}`
        if (result.constructor) {
          stringified = 'new ' + stringified
        }
        return stringified
      }
    },

    JsdocTypeName: result => result.value,

    JsdocTypeTuple: (result, transform) => `[${(result.elements as NonRootResult[]).map(transform).join(', ')}]`,

    JsdocTypeVariadic: (result, transform) => result.meta.position === undefined
      ? '...'
      : applyPosition(result.meta.position, transform(result.element as NonRootResult), '...'),

    JsdocTypeNamePath: (result, transform) => {
      const left = transform(result.left)
      const right = transform(result.right)
      switch (result.pathType) {
        case 'inner':
          return `${left}~${right}`
        case 'instance':
          return `${left}#${right}`
        case 'property':
          return `${left}.${right}`
        case 'property-brackets':
          return `${left}[${right}]`
      }
    },

    JsdocTypeStringValue: result => quote(result.value, result.meta.quote),

    JsdocTypeAny: () => '*',

    JsdocTypeGeneric: (result, transform) => {
      if (result.meta.brackets === 'square') {
        const element = result.elements[0]
        const transformed = transform(element)
        if (element.type === 'JsdocTypeUnion' || element.type === 'JsdocTypeIntersection') {
          return `(${transformed})[]`
        } else {
          return `${transformed}[]`
        }
      } else {
        return `${transform(result.left)}${result.meta.dot ? '.' : ''}<${result.elements.map(transform).join(', ')}>`
      }
    },

    JsdocTypeImport: (result, transform) => `import(${transform(result.element)})`,

    JsdocTypeObjectField: (result, transform) => {
      let text = ''
      if (result.readonly) {
        text += 'readonly '
      }
      if (typeof result.key === 'string') {
        text += quote(result.key, result.meta.quote)
      } else {
        text += transform(result.key)
      }

      if (result.optional) {
        text += '?'
      }

      if (result.right === undefined) {
        return text
      } else {
        return text + `: ${transform(result.right)}`
      }
    },

    JsdocTypeJsdocObjectField: (result, transform) => {
      return `${transform(result.left)}: ${transform(result.right)}`
    },

    JsdocTypeKeyValue: (result, transform) => {
      let text = result.key
      if (result.optional) {
        text += '?'
      }
      if (result.variadic) {
        text = '...' + text
      }

      if (result.right === undefined) {
        return text
      } else {
        return text + `: ${transform(result.right)}`
      }
    },

    JsdocTypeSpecialNamePath: result => `${result.specialType}:${quote(result.value, result.meta.quote)}`,

    JsdocTypeNotNullable: (result, transform) => applyPosition(result.meta.position, transform(result.element), '!'),

    JsdocTypeNull: () => 'null',

    JsdocTypeNullable: (result, transform) => applyPosition(result.meta.position, transform(result.element), '?'),

    JsdocTypeNumber: result => result.value.toString(),

    JsdocTypeObject: (result, transform) => `{${result.elements.map(transform).join((result.meta.separator === 'comma' ? ',' : ';') + ' ')}}`,

    JsdocTypeOptional: (result, transform) => applyPosition(result.meta.position, transform(result.element), '='),

    JsdocTypeSymbol: (result, transform) => `${result.value}(${result.element !== undefined ? transform(result.element) : ''})`,

    JsdocTypeTypeof: (result, transform) => `typeof ${transform(result.element)}`,

    JsdocTypeUndefined: () => 'undefined',

    JsdocTypeUnion: (result, transform) => result.elements.map(transform).join(' | '),

    JsdocTypeUnknown: () => '?',

    JsdocTypeIntersection: (result, transform) => result.elements.map(transform).join(' & '),

    JsdocTypeProperty: result => quote(result.value, result.meta.quote),

    JsdocTypePredicate: (result, transform) => `${transform(result.left)} is ${transform(result.right)}`,

    JsdocTypeIndexSignature: (result, transform) => `[${result.key}: ${transform(result.right)}]`,

    JsdocTypeMappedType: (result, transform) => `[${result.key} in ${transform(result.right)}]`,

    JsdocTypeAsserts: (result, transform) => `asserts ${transform(result.left)} is ${transform(result.right)}`
  }
}

const storedStringifyRules = stringifyRules()

export function stringify (result: RootResult): string {
  return transform(storedStringifyRules, result)
}

1	import { transform, type TransformRules } from './transform'	1✔
2	import { type NonRootResult } from '../result/NonRootResult'
3	import { type RootResult } from '../result/RootResult'
4
5	function applyPosition (position: 'prefix' \| 'suffix', target: string, value: string): string {
6	return position === 'prefix' ? value + target : target + value	74✔
7	}
8
9	export function quote (value: string, quote: 'single' \| 'double' \| undefined): string {	1✔
10	switch (quote) {	251✔
11	case 'double':	251✔
12	return `"${value}"`	25✔
13	case 'single':
14	return `'${value}'`	15✔
15	case undefined:
16	return value	211✔
17	}
18	}
19
20	export function stringifyRules (): TransformRules<string> {	1✔
21	return {	1✔
22	JsdocTypeParenthesis: (result, transform) => `(${result.element !== undefined ? transform(result.element) : ''})`,	28✔
23
24	JsdocTypeKeyof: (result, transform) => `keyof ${transform(result.element)}`,	15✔
25
26	JsdocTypeFunction: (result, transform) => {
27	if (!result.arrow) {	67✔
28	let stringified = result.constructor ? 'new' : 'function'	48✔
29	if (!result.parenthesis) {	48✔
30	return stringified	1✔
31	}
32	stringified += `(${result.parameters.map(transform).join(', ')})`	47✔
33	if (result.returnType !== undefined) {	47✔
34	stringified += `: ${transform(result.returnType)}`	29✔
35	}
36	return stringified	47✔
37	} else {
38	if (result.returnType === undefined) {	19✔
39	throw new Error('Arrow function needs a return type.')	1✔
40	}
41	let stringified = `(${result.parameters.map(transform).join(', ')}) => ${transform(result.returnType)}`	18✔
42	if (result.constructor) {	18✔
43	stringified = 'new ' + stringified	1✔
44	}
45	return stringified	18✔
46	}
47	},
48
49	JsdocTypeName: result => result.value,	357✔
50
51	JsdocTypeTuple: (result, transform) => `[${(result.elements as NonRootResult[]).map(transform).join(', ')}]`,	17✔
52
53	JsdocTypeVariadic: (result, transform) => result.meta.position === undefined	35✔
54	? '...'	35✔
55	: applyPosition(result.meta.position, transform(result.element as NonRootResult), '...'),
56
57	JsdocTypeNamePath: (result, transform) => {
58	const left = transform(result.left)	56✔
59	const right = transform(result.right)	56✔
60	switch (result.pathType) {	56✔
61	case 'inner':	56✔
62	return `${left}~${right}`	5✔
63	case 'instance':
64	return `${left}#${right}`	4✔
65	case 'property':
66	return `${left}.${right}`	43✔
67	case 'property-brackets':
68	return `${left}[${right}]`	4✔
69	}
70	},
71
72	JsdocTypeStringValue: result => quote(result.value, result.meta.quote),	9✔
73
74	JsdocTypeAny: () => '*',	7✔
75
76	JsdocTypeGeneric: (result, transform) => {
77	if (result.meta.brackets === 'square') {	40✔
78	const element = result.elements[0]	14✔
79	const transformed = transform(element)	14✔
80	if (element.type === 'JsdocTypeUnion' \|\| element.type === 'JsdocTypeIntersection') {	14✔
81	return `(${transformed})[]`	1✔
82	} else {
83	return `${transformed}[]`	13✔
84	}
85	} else {
86	return `${transform(result.left)}${result.meta.dot ? '.' : ''}<${result.elements.map(transform).join(', ')}>`	26✔
87	}
88	},
89
90	JsdocTypeImport: (result, transform) => `import(${transform(result.element)})`,	7✔
91
92	JsdocTypeObjectField: (result, transform) => {
93	let text = ''	36✔
94	if (result.readonly) {	36✔
95	text += 'readonly '	1✔
96	}
97	if (typeof result.key === 'string') {	36✔
98	text += quote(result.key, result.meta.quote)	33✔
99	} else {
100	text += transform(result.key)	3✔
101	}
102
103	if (result.optional) {	36✔
104	text += '?'	1✔
105	}
106
107	if (result.right === undefined) {	36✔
108	return text	5✔
109	} else {
110	return text + `: ${transform(result.right)}`	31✔
111	}
112	},
113
114	JsdocTypeJsdocObjectField: (result, transform) => {
115	return `${transform(result.left)}: ${transform(result.right)}`	3✔
116	},
117
118	JsdocTypeKeyValue: (result, transform) => {
119	let text = result.key	31✔
120	if (result.optional) {	31✔
121	text += '?'	1✔
122	}
123	if (result.variadic) {	31✔
124	text = '...' + text	1✔
125	}
126
127	if (result.right === undefined) {	31!
128	return text	×
129	} else {
130	return text + `: ${transform(result.right)}`	31✔
131	}
132	},
133
134	JsdocTypeSpecialNamePath: result => `${result.specialType}:${quote(result.value, result.meta.quote)}`,	12✔
135
136	JsdocTypeNotNullable: (result, transform) => applyPosition(result.meta.position, transform(result.element), '!'),	12✔
137
138	JsdocTypeNull: () => 'null',	3✔
139
140	JsdocTypeNullable: (result, transform) => applyPosition(result.meta.position, transform(result.element), '?'),	11✔
141
142	JsdocTypeNumber: result => result.value.toString(),	9✔
143
144	JsdocTypeObject: (result, transform) => `{${result.elements.map(transform).join((result.meta.separator === 'comma' ? ',' : ';') + ' ')}}`,	35✔
145
146	JsdocTypeOptional: (result, transform) => applyPosition(result.meta.position, transform(result.element), '='),	17✔
147
148	JsdocTypeSymbol: (result, transform) => `${result.value}(${result.element !== undefined ? transform(result.element) : ''})`,	6✔
149
150	JsdocTypeTypeof: (result, transform) => `typeof ${transform(result.element)}`,	16✔
151
152	JsdocTypeUndefined: () => 'undefined',	6✔
153
154	JsdocTypeUnion: (result, transform) => result.elements.map(transform).join(' \| '),	36✔
155
156	JsdocTypeUnknown: () => '?',	5✔
157
158	JsdocTypeIntersection: (result, transform) => result.elements.map(transform).join(' & '),	5✔
159
160	JsdocTypeProperty: result => quote(result.value, result.meta.quote),	54✔
161
162	JsdocTypePredicate: (result, transform) => `${transform(result.left)} is ${transform(result.right)}`,	1✔
163
164	JsdocTypeIndexSignature: (result, transform) => `[${result.key}: ${transform(result.right)}]`,	2✔
165
166	JsdocTypeMappedType: (result, transform) => `[${result.key} in ${transform(result.right)}]`,	1✔
167
168	JsdocTypeAsserts: (result, transform) => `asserts ${transform(result.left)} is ${transform(result.right)}`	1✔
169	}
170	}
171
172	const storedStringifyRules = stringifyRules()	1✔
173
174	export function stringify (result: RootResult): string {	1✔
175	return transform(storedStringifyRules, result)	235✔
176	}

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