import type { JsdocObjectFieldResult, KeyValueResult, ObjectFieldResult, PropertyResult, TypeParameterResult, CallSignatureResult, ConstructorSignatureResult, MethodSignatureResult, IndexedAccessIndexResult, ComputedPropertyResult, ComputedMethodResult } from './NonRootResult.js' /** * A parse result that corresponds to a valid type expression. */ export type RootResult = NameResult | UnionResult | GenericResult | StringValueResult | NullResult | UndefinedResult | AnyResult | UnknownResult | FunctionResult | ObjectResult | NamePathResult | SymbolResult | TypeOfResult | KeyOfResult | ImportResult | TupleResult | SpecialNamePath | OptionalResult | NullableResult | NotNullableResult | VariadicResult | ParenthesisResult | IntersectionResult | NumberResult | PredicateResult | AssertsResult | ReadonlyArrayResult | AssertsPlainResult | ConditionalResult | TemplateLiteralResult export type QuoteStyle = 'single' | 'double' /** * `element` is optional. */ export interface OptionalResult { type: 'JsdocTypeOptional' element: T meta: { position: 'prefix' | 'suffix' } } /** * A nullable type. */ export interface NullableResult { type: 'JsdocTypeNullable' element: T meta: { position: 'prefix' | 'suffix' } } /** * A not nullable type. */ export interface NotNullableResult { type: 'JsdocTypeNotNullable' element: T meta: { position: 'prefix' | 'suffix' } } /** * A rest or spread parameter. It can either occur in `@param` tags or as last parameter of a function, * or it is a spread tuple or object type and can occur inside these. For any mode that is not `jsdoc` this can * only occur in position `'suffix'`. */ export interface VariadicResult { type: 'JsdocTypeVariadic' element?: T meta: { position: 'prefix' | 'suffix' | undefined squareBrackets: boolean } } /** * A type name. */ export interface NameResult { type: 'JsdocTypeName' value: string } /** * A type union. */ export interface UnionResult { type: 'JsdocTypeUnion' elements: RootResult[] meta?: { spacing: string } } /** * A generic type. The property `left` is the generic type that has `elements` as type values for its type parameters. * Array types that are written as `Type[]` always have the name `Array` as the `left` type and `elements` will contain * only one element (in this case the name `Type`). To differentiate `Type[]` and `Array` there is the meta * property * `brackets`. */ export interface GenericResult { type: 'JsdocTypeGeneric' left: RootResult elements: RootResult[] infer?: boolean meta: { brackets: 'angle' | 'square' dot: boolean, elementSpacing?: string } } /** * A string value as a type. */ export interface StringValueResult { type: 'JsdocTypeStringValue' value: string meta: { quote: QuoteStyle } } /** * The `null` type. */ export interface NullResult { type: 'JsdocTypeNull' } /** * The `undefined` type. */ export interface UndefinedResult { type: 'JsdocTypeUndefined' } /** * The `any` type, represented by `*` (`any` is parsed as a name). */ export interface AnyResult { type: 'JsdocTypeAny' } /** * The unknown type, represented by `?` (`unknown` is parsed as a name). */ export interface UnknownResult { type: 'JsdocTypeUnknown' } /** * A function type. Has `parameters` which can be named, if the grammar supports it. Some grammars only allow named * `this` and `new` parameters. Named parameters are returned as {@link KeyValueResult}s. It can have a `returnType`. * It can be a normal function type or an arrow, which is indicated by `arrow`. If `parenthesis` is false, it is any * kind of function without specified parameters or return type. */ export interface FunctionResult { type: 'JsdocTypeFunction' parameters: Array returnType?: RootResult constructor: boolean arrow: boolean parenthesis: boolean typeParameters?: TypeParameterResult[] meta?: { parameterSpacing: string typeParameterSpacing: string preReturnMarkerSpacing: string postReturnMarkerSpacing: string postGenericSpacing?: string } } /** * An object type. Contains entries which can be {@link KeyValueResult}s or {@link NameResult}s. In most grammars the * keys need to be {@link NameResult}s. In some grammars it possible that an entry is only a {@link RootResult} or a * {@link NumberResult} without a key. The separator is `'comma'` by default. */ export interface ObjectResult { type: 'JsdocTypeObject' elements: Array meta: { separator: 'comma' | 'semicolon' | 'linebreak' | 'comma-and-linebreak' | 'semicolon-and-linebreak' | undefined separatorForSingleObjectField?: boolean trailingPunctuation?: boolean propertyIndent?: string } } export type SpecialNamePathType = 'module' | 'event' | 'external' /** * A module type. Often this is a `left` type of {@link NamePathResult}. */ export interface SpecialNamePath { type: 'JsdocTypeSpecialNamePath' value: string specialType: Type meta: { quote: QuoteStyle | undefined } } /** * A name path type. This can be a property path separated by `.` or an inner or static member (`~`, `#`). */ export interface NamePathResult { type: 'JsdocTypeNamePath' left: RootResult right: PropertyResult | SpecialNamePath<'event'> | IndexedAccessIndexResult pathType: 'inner' | 'instance' | 'property' | 'property-brackets' } /** * A symbol type. Only available in `jsdoc` mode. */ export interface SymbolResult { type: 'JsdocTypeSymbol' value: string element?: NumberResult | NameResult | VariadicResult } /** * A typeof type. The `element` normally should be a name. */ export interface TypeOfResult { type: 'JsdocTypeTypeof' element: RootResult } /** * A keyof type. The `element` normally should be a name. */ export interface KeyOfResult { type: 'JsdocTypeKeyof' element: RootResult } /** * An import type. The `element` is {@link StringValueResult} representing the path. Often the `left` side of an * {@link NamePathResult}. */ export interface ImportResult { type: 'JsdocTypeImport' element: StringValueResult } /** * A tuple type containing multiple `elements`. */ export interface TupleResult { type: 'JsdocTypeTuple' elements: RootResult[] | KeyValueResult[], meta?: { elementSpacing: string } } /** * A type enclosed in parenthesis. Often {@link UnionResult}s ot {@link IntersectionResult}s. */ export interface ParenthesisResult { type: 'JsdocTypeParenthesis' element: RootResult } /** * An intersection type. */ export interface IntersectionResult { type: 'JsdocTypeIntersection' elements: RootResult[] } /** * A number. Can be the key of an {@link ObjectResult} entry or the parameter of a {@link SymbolResult}. * Is a {@link NonRootResult}. */ export interface NumberResult { type: 'JsdocTypeNumber' value: number } /** * A typescript predicate. Is used in return annotations like this: `@return {x is string}`. */ export interface PredicateResult { type: 'JsdocTypePredicate' left: NameResult right: RootResult } /** * An asserts result. Is used like this: `@return {asserts foo is Bar}` */ export interface AssertsResult { type: 'JsdocTypeAsserts' left: NameResult right: RootResult } /** * A TypeScript readonly modifier. Is used like this: `readonly string[]`. */ export interface ReadonlyArrayResult { type: 'JsdocTypeReadonlyArray' element: RootResult } /** * An asserts result without `is`. Is used like this: `@return {asserts foo}` */ export interface AssertsPlainResult { type: 'JsdocTypeAssertsPlain' element: NameResult } /** * A TypeScript conditional. Is used like this: `A extends B ? C : D`. */ export interface ConditionalResult { type: 'JsdocTypeConditional' checksType: RootResult extendsType: RootResult trueType: RootResult falseType: RootResult } /** * A TypeScript template literal. Is used like: `\`someText${someType}\`` */ export interface TemplateLiteralResult { type: 'JsdocTypeTemplateLiteral' literals: string[], interpolations: RootResult[] }