@supernovaio/cli/dist/code-analyzer/components/parser/types.d.ts

Supernova.io Command Line Interface

import * as ts from "typescript";
export type InterfaceOrTypeAliasDeclaration = ts.InterfaceDeclaration | ts.TypeAliasDeclaration;
export interface StringIndexedObject<T> {
    [key: string]: T;
}
export interface ComponentDoc {
    description: string;
    displayName: string | null;
    exportName: string;
    exportType?: "explicit-export" | "inferred-export" | "star-export";
    expression?: ts.Symbol;
    filePath: string;
    methods: Method[];
    props: Props;
    rootExpression?: ts.Symbol;
    tags?: StringIndexedObject<string>;
}
export interface Props extends StringIndexedObject<PropItem> {
}
export interface PropItem {
    declarations?: ParentType[];
    defaultValue: unknown;
    description: string;
    name: string;
    parent?: ParentType;
    required: boolean;
    resolvedType: ResolvedType;
    tags?: StringIndexedObject<string>;
    type: PropItemType;
}
export interface Method {
    description: string;
    docblock: string;
    modifiers: string[];
    name: string;
    params: MethodParameter[];
    returns?: null | {
        description?: null | string;
        type?: string;
    };
}
export interface MethodParameter {
    description?: null | string;
    name: string;
    type: MethodParameterType;
}
export interface MethodParameterType {
    name: string;
}
export interface Component {
    name: string;
}
export interface ResolvedPropItemType {
    name: string;
    raw?: string;
    value?: any;
}
export interface PropItemType {
    name: string;
    raw?: string;
    value?: any;
}
export interface ParentType {
    fileName: string;
    name: string;
}
export type PropFilter = (props: PropItem, component: Component) => boolean;
export type ComponentNameResolver = (exp: ts.Symbol, source: ts.SourceFile) => false | null | string | undefined;
export interface ParserOptions {
    componentNameResolver?: ComponentNameResolver;
    customComponentTypes?: string[];
    propFilter?: PropFilter | StaticPropFilter;
    savePropValueAsString?: boolean;
    shouldExtractLiteralValuesFromEnum?: boolean;
    shouldExtractValuesFromUnion?: boolean;
    shouldIncludeExpression?: boolean;
    shouldIncludePropTagMap?: boolean;
    shouldRemoveUndefinedFromOptional?: boolean;
    shouldSortUnions?: boolean;
    skipChildrenPropWithoutDoc?: boolean;
}
export interface StaticPropFilter {
    skipPropsWithName?: string | string[];
    skipPropsWithoutDoc?: boolean;
}
export declare const defaultParserOpts: ParserOptions;
export interface FileParser {
    parse(filePathOrPaths: string | string[]): ComponentDoc[];
    parseWithProgramProvider(filePathOrPaths: string | string[], programProvider?: () => ts.Program): ComponentDoc[];
}
export interface JSDoc {
    description: string;
    fullComment: string;
    tags: StringIndexedObject<string>;
}
interface ResolvedTypeBase {
    isArray?: boolean;
    raw: string;
}
interface ResolvedUnionType extends ResolvedTypeBase {
    kind: ResolvedTypeKind.Union;
    types: ResolvedType[];
}
interface ResolvedSpecificType extends ResolvedTypeBase {
    kind: Exclude<ResolvedTypeKind, ResolvedTypeKind.Union>;
}
export type ResolvedType = ResolvedUnionType | ResolvedSpecificType;
export declare enum ResolvedTypeKind {
    Any = "any",
    Boolean = "boolean",
    BooleanLiteral = "booleanLiteral",
    Function = "function",
    Null = "null",
    Number = "number",
    NumberLiteral = "numberLiteral",
    Object = "object",
    Slot = "slot",
    String = "string",
    StringLiteral = "stringLiteral",
    Undefined = "undefined",
    Union = "union"
}
export {};
//# sourceMappingURL=types.d.ts.map