@bitjson/typedoc

@bitjson/typedoc

Version 0.15.0-0
Published 5 years ago
1.32 MB
11 dependencies
Apache-2.0 license

Install

npm i @bitjson/typedoc

yarn add @bitjson/typedoc

pnpm add @bitjson/typedoc

Overview

Create api documentation for TypeScript projects.

Index

Functions

function createMinimatch

createMinimatch: (patterns: string[]) => IMinimatch[];

function normalizePath

normalizePath: (path: string) => string;

function resetReflectionID

resetReflectionID: () => void;

Classes

class Application

class Application extends ChildableComponent<
    Application,
    AbstractComponent<Application>
> {}

constructor

constructor(options?: Object);

property application

readonly application: Application;

property converter

converter: Converter;

property exclude

exclude: string[];

property ignoreCompilerErrors

ignoreCompilerErrors: boolean;

property isCLI

readonly isCLI: boolean;

property logger

logger: Logger;

property loggerType

loggerType: string | Function;

property options

options: Options;

property plugins

plugins: PluginHost;

property renderer

renderer: Renderer;

property serializer

serializer: Serializer;

property VERSION

static VERSION: string;

method bootstrap

protected bootstrap: (options?: Object) => OptionsReadResult;

method convert

convert: (src: string[]) => ProjectReflection | undefined;

method expandInputFiles

expandInputFiles: (inputFiles?: string[]) => string[];

method generateDocs

generateDocs: {
    (src: string[], out: string): boolean;
    (project: ProjectReflection, out: string): boolean;
};

method generateJson

generateJson: {
    (src: string[], out: string): boolean;
    (project: ProjectReflection, out: string): boolean;
};

method getTypeScriptPath

getTypeScriptPath: () => string;

method getTypeScriptVersion

getTypeScriptVersion: () => string;

method toString

toString: () => string;

class AssetsPlugin

class AssetsPlugin extends RendererComponent {}

property copyDefaultAssets

copyDefaultAssets: boolean;

method initialize

initialize: () => void;

class CliApplication

class CliApplication extends Application {}

property help

help: boolean;

property isCLI

readonly isCLI: boolean;

property json

json: string;

property out

out: string;

property version

version: boolean;

method bootstrap

protected bootstrap: (options?: Object) => OptionsReadResult;

class ContainerReflection

class ContainerReflection extends Reflection {}

property categories

categories?: ReflectionCategory[];

property children

children?: DeclarationReflection[];

property groups

groups?: ReflectionGroup[];

method getChildrenByKind

getChildrenByKind: (kind: ReflectionKind) => DeclarationReflection[];

method toObject

toObject: () => any;

method traverse

traverse: (callback: TraverseCallback) => void;

class DeclarationReflection

class DeclarationReflection
    extends ContainerReflection
    implements DefaultValueContainer, TypeContainer, TypeParameterContainer {}

property defaultValue

defaultValue?: string;

property extendedBy

extendedBy?: Type[];

property extendedTypes

extendedTypes?: Type[];

property getSignature

getSignature?: SignatureReflection;

property implementationOf

implementationOf?: Type;

property implementedBy

implementedBy?: Type[];

property implementedTypes

implementedTypes?: Type[];

property indexSignature

indexSignature?: SignatureReflection;

property inheritedFrom

inheritedFrom?: Type;

property overwrites

overwrites?: Type;

property setSignature

setSignature?: SignatureReflection;

property signatures

signatures?: SignatureReflection[];

property type

type?: Type;

property typeHierarchy

typeHierarchy?: DeclarationHierarchy;

property typeParameters

typeParameters?: TypeParameterReflection[];

method getAllSignatures

getAllSignatures: () => SignatureReflection[];

method hasGetterOrSetter

hasGetterOrSetter: () => boolean;

method toObject

toObject: () => any;

method toString

toString: () => string;

method traverse

traverse: (callback: TraverseCallback) => void;

class DefaultTheme

class DefaultTheme extends Theme {}

constructor

constructor(renderer: Renderer, basePath: string);

property MAPPINGS

static MAPPINGS: TemplateMapping[];

property URL_PREFIX

static URL_PREFIX: RegExp;

method applyAnchorUrl

static applyAnchorUrl: (reflection: Reflection, container: Reflection) => void;

method applyGroupClasses

static applyGroupClasses: (group: ReflectionGroup) => void;

method applyReflectionClasses

static applyReflectionClasses: (reflection: DeclarationReflection) => void;

method buildUrls

static buildUrls: (
    reflection: DeclarationReflection,
    urls: UrlMapping[]
) => UrlMapping[];

method getEntryPoint

getEntryPoint: (project: ProjectReflection) => ContainerReflection;

method getMapping

static getMapping: (
    reflection: DeclarationReflection
) => TemplateMapping | undefined;

method getNavigation

getNavigation: (project: ProjectReflection) => NavigationItem;

method getUrl

static getUrl: (
    reflection: Reflection,
    relative?: Reflection,
    separator?: string
) => string;

method getUrls

getUrls: (project: ProjectReflection) => UrlMapping[];

method isOutputDirectory

isOutputDirectory: (path: string) => boolean;

method toStyleClass

static toStyleClass: (str: string) => string;

class Event

class Event {}

constructor

constructor(name: string);

property isDefaultPrevented

readonly isDefaultPrevented: boolean;

property isPropagationStopped

readonly isPropagationStopped: boolean;

property name

readonly name: string;

method preventDefault

preventDefault: () => void;

method stopPropagation

stopPropagation: () => void;

class EventDispatcher

class EventDispatcher {}

method listenTo

listenTo: (
    obj: EventDispatcher,
    name: EventMap | string,
    callback?: EventCallback,
    priority?: number
) => this;

method listenToOnce

listenToOnce: {
    (obj: EventDispatcher, eventMap: EventMap): any;
    (
        obj: EventDispatcher,
        name: string,
        callback: EventCallback,
        priority?: number
    ): any;
};

method off

off: {
    (): any;
    (eventMap: EventMap, context?: any): any;
    (name: string, callback?: EventCallback, context?: any): any;
};

method on

on: {
    (eventMap: EventMap, context?: any): any;
    (
        eventMap: EventMap,
        callback?: EventCallback,
        context?: any,
        priority?: number
    ): any;
    (
        name: string,
        callback: EventCallback,
        context?: any,
        priority?: number
    ): any;
};

method once

once: {
    (eventMap: EventMap, context?: any): any;
    (name: string, callback: EventCallback, context?: any, priority?: any): any;
};

method stopListening

stopListening: (
    obj?: EventDispatcher,
    name?: EventMap | string,
    callback?: EventCallback
) => this;

method trigger

trigger: (name: Event | EventMap | string, ...args: any[]) => this;

class JavascriptIndexPlugin

class JavascriptIndexPlugin extends RendererComponent {}

method initialize

initialize: () => void;

class LayoutPlugin

class LayoutPlugin extends RendererComponent {}

method initialize

initialize: () => void;

class MarkedLinksPlugin

class MarkedLinksPlugin extends ContextAwareRendererComponent {}

property listInvalidSymbolLinks

listInvalidSymbolLinks: boolean;

method initialize

initialize: () => void;

method onEndRenderer

onEndRenderer: (event: RendererEvent) => void;

method onParseMarkdown

onParseMarkdown: (event: MarkdownEvent) => void;

method splitLinkText

static splitLinkText: (text: string) => { caption: string; target: string };

class MarkedPlugin

class MarkedPlugin extends ContextAwareRendererComponent {}

property includeSource

includeSource: string;

property mediaSource

mediaSource: string;

method getHighlighted

getHighlighted: (text: string, lang?: string) => string;

method initialize

initialize: () => void;

method onBeginRenderer

protected onBeginRenderer: (event: RendererEvent) => void;

method onParseMarkdown

onParseMarkdown: (event: MarkdownEvent) => void;

method parseMarkdown

parseMarkdown: (text: string, context: any) => string;

class NavigationItem

class NavigationItem {}

constructor

constructor(
    title?: string,
    url?: string,
    parent?: NavigationItem,
    cssClasses?: string,
    reflection?: Reflection
);

property children

children?: NavigationItem[];

property cssClasses

cssClasses: string;

property dedicatedUrls

dedicatedUrls?: string[];

property isCurrent

isCurrent?: boolean;

property isGlobals

isGlobals?: boolean;

property isInPath

isInPath?: boolean;

property isLabel

isLabel?: boolean;

property isVisible

isVisible?: boolean;

property parent

parent?: NavigationItem;

property reflection

reflection?: Reflection;

property title

title: string;

property url

url: string;

method create

static create: (
    reflection: Reflection,
    parent?: NavigationItem,
    useShortNames?: boolean
) => NavigationItem;

class NavigationPlugin

class NavigationPlugin extends RendererComponent {}

navigation: NavigationItem;

method initialize

initialize: () => void;

class ParameterReflection

class ParameterReflection
    extends Reflection
    implements DefaultValueContainer, TypeContainer {}

property defaultValue

defaultValue?: string;

property parent

parent?: SignatureReflection;

property type

type?: Type;

method toObject

toObject: () => any;

method toString

toString: () => string;

method traverse

traverse: (callback: TraverseCallback) => void;

class PrettyPrintPlugin

class PrettyPrintPlugin extends RendererComponent {}

property IGNORED_TAGS

static IGNORED_TAGS: {
    area: boolean;
    base: boolean;
    br: boolean;
    wbr: boolean;
    col: boolean;
    command: boolean;
    embed: boolean;
    hr: boolean;
    img: boolean;
    input: boolean;
    link: boolean;
    meta: boolean;
    param: boolean;
    source: boolean;
};

property PRE_TAGS

static PRE_TAGS: {
    pre: boolean;
    code: boolean;
    textarea: boolean;
    script: boolean;
    style: boolean;
};

method initialize

initialize: () => void;

method onRendererEndPage

onRendererEndPage: (event: PageEvent) => void;

class ProjectReflection

class ProjectReflection extends ContainerReflection {}

constructor

constructor(name: string);

property directory

directory: SourceDirectory;

property files

files: SourceFile[];

property name

name: string;

property packageInfo

packageInfo: any;

property readme

readme?: string;

property reflections

reflections: { [id: number]: Reflection };

property symbolMapping

symbolMapping: { [symbolId: number]: number };

method findReflectionByName

findReflectionByName: (arg: string | string[]) => Reflection | undefined;

method getReflectionsByKind

getReflectionsByKind: (kind: ReflectionKind) => Reflection[];

method isProject

isProject: () => boolean;

class Reflection

abstract class Reflection {}

constructor

constructor(name: string, kind: ReflectionKind, parent?: Reflection);

property anchor

anchor?: string;

property comment

comment?: Comment;

property cssClasses

cssClasses?: string;

property decorates

decorates?: Type[];

property decorators

decorators?: Decorator[];

property flags

flags: ReflectionFlags;

property hasOwnDocument

hasOwnDocument?: boolean;

property id

id: number;

property kind

kind: ReflectionKind;

property kindString

kindString?: string;

property name

name: string;

property originalName

originalName: string;

property parent

parent?: Reflection;

property sources

sources?: SourceReference[];

property url

url?: string;

method findReflectionByName

findReflectionByName: (arg: string | string[]) => Reflection | undefined;

method getAlias

getAlias: () => string;

method getChildByName

getChildByName: (arg: string | string[]) => Reflection | undefined;

method getFullName

getFullName: (separator?: string) => string;

method hasComment

hasComment: () => boolean;

method hasGetterOrSetter

hasGetterOrSetter: () => boolean;

method isProject

isProject: () => boolean;

method kindOf

kindOf: (kind: ReflectionKind | ReflectionKind[]) => boolean;

method setFlag

setFlag: (flag: ReflectionFlag, value?: boolean) => void;

method toObject

toObject: () => any;

method toString

toString: () => string;

method toStringHierarchy

toStringHierarchy: (indent?: string) => string;

method traverse

traverse: (callback: TraverseCallback) => void;

class Renderer

class Renderer extends ChildableComponent<Application, RendererComponent> {}

property disableOutputCheck

disableOutputCheck: boolean;

property entryPoint

entryPoint: string;

property gaID

gaID: string;

property gaSite

gaSite: string;

property hideGenerator

hideGenerator: boolean;

property theme

theme?: Theme;

property themeName

themeName: string;

property toc

toc: string[];

method getDefaultTheme

static getDefaultTheme: () => string;

method getThemeDirectory

static getThemeDirectory: () => string;

method initialize

initialize: () => void;

method render

render: (project: ProjectReflection, outputDirectory: string) => void;

class SignatureReflection

class SignatureReflection
    extends Reflection
    implements TypeContainer, TypeParameterContainer {}

property implementationOf

implementationOf?: Type;

property inheritedFrom

inheritedFrom?: Type;

property overwrites

overwrites?: Type;

property parameters

parameters?: ParameterReflection[];

property parent

parent?: ContainerReflection;

property type

type?: Type;

property typeParameters

typeParameters?: TypeParameterReflection[];

method getParameterTypes

getParameterTypes: () => Type[];

method toObject

toObject: () => any;

method toString

toString: () => string;

method traverse

traverse: (callback: TraverseCallback) => void;

class TocPlugin

class TocPlugin extends RendererComponent {}

method buildToc

static buildToc: (
    model: Reflection,
    trail: Reflection[],
    parent: NavigationItem,
    restriction?: string[]
) => void;

method initialize

initialize: () => void;

class TypeParameterReflection

class TypeParameterReflection extends Reflection implements TypeContainer {}

constructor

constructor(type: TypeParameterType, parent?: Reflection);

property parent

parent?: DeclarationReflection;

property type

type?: Type;

method toObject

toObject: () => any;

class UrlMapping

class UrlMapping {}

constructor

constructor(url: string, model: any, template: string);

property model

model: any;

property template

template: string;

property url

url: string;

Interfaces

interface DeclarationHierarchy

interface DeclarationHierarchy {}

property isTarget

isTarget?: boolean;

property next

next?: DeclarationHierarchy;

property types

types: Type[];

interface Decorator

interface Decorator {}

property arguments

arguments?: any;

property name

name: string;

property type

type?: Type;

interface TypeParameterContainer

interface TypeParameterContainer extends Reflection {}

property typeParameters

typeParameters?: TypeParameterReflection[];

Enums

enum ReflectionFlag

enum ReflectionFlag {
    None = 0,
    Private = 1,
    Protected = 2,
    Public = 4,
    Static = 8,
    Exported = 16,
    ExportAssignment = 32,
    External = 64,
    Optional = 128,
    DefaultValue = 256,
    Rest = 512,
    ConstructorProperty = 1024,
    Abstract = 2048,
    Const = 4096,
    Let = 8192,
}

member Abstract

Abstract = 2048

member Const

Const = 4096

member ConstructorProperty

ConstructorProperty = 1024

member DefaultValue

DefaultValue = 256

member ExportAssignment

ExportAssignment = 32

member Exported

Exported = 16

member External

External = 64

member Let

Let = 8192

member None

None = 0

member Optional

Optional = 128

member Private

Private = 1

member Protected

Protected = 2

member Public

Public = 4

member Rest

Rest = 512

member Static

Static = 8

enum ReflectionKind

enum ReflectionKind {
    Global = 0,
    ExternalModule = 1,
    Module = 2,
    Enum = 4,
    EnumMember = 16,
    Variable = 32,
    Function = 64,
    Class = 128,
    Interface = 256,
    Constructor = 512,
    Property = 1024,
    Method = 2048,
    CallSignature = 4096,
    IndexSignature = 8192,
    ConstructorSignature = 16384,
    Parameter = 32768,
    TypeLiteral = 65536,
    TypeParameter = 131072,
    Accessor = 262144,
    GetSignature = 524288,
    SetSignature = 1048576,
    ObjectLiteral = 2097152,
    TypeAlias = 4194304,
    Event = 8388608,
    ClassOrInterface = 384,
    VariableOrProperty = 1056,
    FunctionOrMethod = 2112,
    SomeSignature = 1601536,
    SomeModule = 3,
    SomeType = 4391168,
    SomeValue = 2097248,
}

member Accessor

Accessor = 262144

member CallSignature

CallSignature = 4096

member Class

Class = 128

member ClassOrInterface

ClassOrInterface = 384

member Constructor

Constructor = 512

member ConstructorSignature

ConstructorSignature = 16384

member Enum

Enum = 4

member EnumMember

EnumMember = 16

member Event

Event = 8388608

member ExternalModule

ExternalModule = 1

member Function

Function = 64

member FunctionOrMethod

FunctionOrMethod = 2112

member GetSignature

GetSignature = 524288

member Global

Global = 0

member IndexSignature

IndexSignature = 8192

member Interface

Interface = 256

member Method

Method = 2048

member Module

Module = 2

member ObjectLiteral

ObjectLiteral = 2097152

member Parameter

Parameter = 32768

member Property

Property = 1024

member SetSignature

SetSignature = 1048576

member SomeModule

SomeModule = 3

member SomeSignature

SomeSignature = 1601536

member SomeType

SomeType = 4391168

member SomeValue

SomeValue = 2097248

member TypeAlias

TypeAlias = 4194304

member TypeLiteral

TypeLiteral = 65536

member TypeParameter

TypeParameter = 131072

member Variable

Variable = 32

member VariableOrProperty

VariableOrProperty = 1056

enum TraverseProperty

enum TraverseProperty {
    Children = 0,
    Parameters = 1,
    TypeLiteral = 2,
    TypeParameter = 3,
    Signatures = 4,
    IndexSignature = 5,
    GetSignature = 6,
    SetSignature = 7,
}

member Children

Children = 0

member GetSignature

GetSignature = 6

member IndexSignature

IndexSignature = 5

member Parameters

Parameters = 1

member SetSignature

SetSignature = 7

member Signatures

Signatures = 4

member TypeLiteral

TypeLiteral = 2

member TypeParameter

TypeParameter = 3

Package Files (25)

Dependencies (11)

Dev Dependencies (11)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@bitjson/typedoc.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@bitjson/typedoc)

HTML

<a href="https://www.jsdocs.io/package/@bitjson/typedoc"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 years ago.
Package analyzed in 6421 ms.
Missing or incorrect documentation? Open an issue for this package.