@markdoc/markdoc

Types Source

Search for an npm package

parse

decl source

export function parse(content: string | import("markdown-it").Token[], args?: string | ParserArgs): default

Referenced by

default

resolve

decl source decl source

export function resolve<C extends Config = Config>(content: default, config: C): default

export function resolve<C extends Config = Config>(content: default[], config: C): default[]

Referenced by

default

transform

decl source decl source

export function transform<C extends Config = Config>(node: default, config?: C): RenderableTreeNode

export function transform<C extends Config = Config>(nodes: default[], config?: C): RenderableTreeNode[]

Referenced by

default

validate

decl source

export function validate<C extends Config = Config>(node: default, options?: C): ValidateError[]

Referenced by

default

createElement

decl source

export function createElement(name: string | {

key?: string | number;

}, attributes?: {}, ...children: any[]): {

key?: string | number | undefined;

};

attributes: {};

children: any[];

}

Referenced by

default

document

decl source

export const document: Schema = ...

heading

decl source

export const heading: Schema = ...

paragraph

decl source

export const paragraph: Schema = ...

image

decl source

export const image: Schema = ...

fence

decl source

export const fence: Schema = ...

blockquote

decl source

export const blockquote: Schema = ...

item

decl source

export const item: Schema = ...

list

decl source

export const list: Schema = ...

hr

decl source

export const hr: Schema = ...

table

decl source

export const table: Schema = ...

td

decl source

export const td: Schema = ...

th

decl source

export const th: Schema = ...

tr

decl source

export const tr: Schema = ...

tbody

decl source

export const tbody: Schema = ...

thead

decl source

export const thead: Schema = ...

strong

decl source

export const strong: Schema = ...

em

decl source

export const em: Schema = ...

inline

decl source

export const inline: Schema = ...

link

decl source

export const link: Schema = ...

code

decl source

export const code: Schema = ...

text

decl source

export const text: Schema = ...

hardbreak

decl source

export const hardbreak: Schema = ...

softbreak

decl source

export const softbreak: Schema = ...

comment

decl source

export const comment: {

attributes: {

content: {

type: StringConstructor;

required: boolean;

};

} = ...

node

decl source

export const node: {} = ...

}

Referenced by

default

functions

decl

export const functions: {

and: ConfigFunction;

or: ConfigFunction;

not: ConfigFunction;

equals: ConfigFunction;

default: ConfigFunction;

debug: ConfigFunction;

} = ...

globalAttributes

decl source

export const globalAttributes: AttributesSchema = ...

Unexported symbols referenced here

AttributesSchema

decl source

type AttributesSchema = Schema["attributes"]

Referenced by

globalAttributes

transforms

decl

export const transforms: (typeof default)[] = ...

Unexported symbols referenced here

transform

decl source

function transform(document: default): void

Referenced by

transforms
default

renderers

decl

export const renderers: {

html: typeof default;

react: typeof default;

reactStatic: typeof default;

} = ...

Unexported symbols referenced here

render

decl source

function render(node: RenderableTreeNodes): string

Referenced by

renderers
default

dynamic

decl source

function dynamic(node: RenderableTreeNodes, React: ReactShape, { components }?: {

components?: {} | undefined;

}): import("react").ReactNode

Referenced by

renderers
default

reactStatic

decl source

function reactStatic(node: RenderableTreeNodes): string

Referenced by

renderers
default

ReactShape

decl source

type ReactShape = Readonly<{

createElement: typeof import("react").createElement;

Fragment: typeof import("react").Fragment;

Referenced by

dynamic

Ast

decl

export const Ast: {

fromJSON: typeof fromJSON;

isAst(value?: any): value is AstType;

isFunction(value?: any): value is default;

isVariable(value?: any): value is default;

getAstValues(value: any): Generator<AstType, void, unknown>;

resolve(value: any, config?: Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>): any;

Function: typeof default;

Node: typeof default;

Variable: typeof default;

} = ...

Unexported symbols referenced here

fromJSON

decl source

function fromJSON(text: string): default | default[]

Referenced by

Function

decl source

class Function implements AstType {

constructor(name: string, parameters: Record<string, any>)

readonly $$mdtype: "Function";

parameters: Record<string, any>;

resolve(config?: Config): any;

}

Referenced by

Ast
default
Function
ConfigFunction

Variable

decl source

class Variable implements AstType {

constructor(path?: (string | number)[])

readonly $$mdtype: "Variable";

path: (string | number)[];

resolve({ variables }?: Config): any;

}

Referenced by

Ast
default
Variable

Tokenizer

decl source

export class Tokenizer {

constructor(config?: import("markdown-it").Options & {

allowIndentation?: boolean;

allowComments?: boolean;

})

tokenize(content: string): import("markdown-it").Token[];

}

Referenced by

default

parseTags

decl source

export function parseTags(content: string, firstLine?: number): import("markdown-it").Token[]

Referenced by

default

transformer

decl

export const transformer: Transformer = ...

validator

decl source

export function validator(node: default, config: Config): ValidationError[] | Promise<ValidationError[]>

Referenced by

default

truthy

decl source

export function truthy(value: any): boolean

Referenced by

default

format

decl source

export function format(v: Value, options?: Options): string

Referenced by

default

Unexported symbols referenced here

Options

decl source

type Options = {

allowIndentation?: boolean;

maxTagOpeningWidth?: number;

parent?: default;

indent?: number;

}

Referenced by

format

default

decl source

export class default {

constructor(config: Config)

static nodes: typeof "/node_modules/@markdoc/markdoc/dist/src/schema";

static tags: {

else: Schema<Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: import("@markdoc/markdoc").default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>, string>;

if: Schema<Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: import("@markdoc/markdoc").default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>, string>;

partial: Schema<Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: import("@markdoc/markdoc").default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>, string>;

slot: Schema<Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: import("@markdoc/markdoc").default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>, string>;

table: Schema<Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: import("@markdoc/markdoc").default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>, string>;

};

static functions: {

and: ConfigFunction;

or: ConfigFunction;

not: ConfigFunction;

equals: ConfigFunction;

default: ConfigFunction;

debug: ConfigFunction;

};

static globalAttributes: Record<string, SchemaAttribute> | undefined;

static renderers: {

html: typeof default;

react: typeof default;

reactStatic: typeof default;

};

static transforms: typeof default[];

static Ast: {

fromJSON: (text: string) => import("@markdoc/markdoc").default | import("@markdoc/markdoc").default[];

isAst(value?: any): value is AstType;

isFunction(value?: any): value is default;

isVariable(value?: any): value is default;

getAstValues(value: any): Generator<AstType, void, unknown>;

resolve(value: any, config?: Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: import("@markdoc/markdoc").default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>): any;

Function: typeof default;

Node: typeof import("@markdoc/markdoc").default;

Variable: typeof default;

};

static Tag: typeof import("@markdoc/markdoc").default;

static Tokenizer: typeof import("@markdoc/markdoc").default;

static parseTags: typeof parseTags;

static transformer: Transformer;

static validator: typeof import("@markdoc/markdoc").default;

static parse: typeof parse;

static transform: typeof transform;

static validate: typeof validate;

static createElement: typeof createElement;

static truthy: typeof truthy;

static format: typeof import("@markdoc/markdoc").default;

config: Readonly<Partial<{

nodes: Partial<Record<NodeType, Schema<Readonly<Partial<any>>, string>>>;

tags: Record<string, Schema<Readonly<Partial<any>>, string>>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: import("@markdoc/markdoc").default[] | undefined;

validateFunctions?: boolean | undefined;

environment?: string | undefined;

} | undefined;

}>>;

parse: typeof parse;

resolve: (content: Parameters<typeof resolve>[0]) => import("@markdoc/markdoc").default[];

transform: (content: Parameters<typeof transform>[0]) => RenderableTreeNode[];

validate: (content: Parameters<typeof validate>[0]) => ValidateError[];

}

Node

decl source

export class Node implements AstType {

constructor(type?: NodeType, attributes?: Record<string, any>, children?: default[], tag?: string)

readonly $$mdtype: "Node";

attributes: Record<string, any>;

slots: Record<string, default>;

children: default[];

errors: ValidationError[];

lines: number[];

type: NodeType;

tag?: string;

annotations: AttributeValue[];

inline: boolean;

location?: Location;

walk(): Generator<default, void, unknown>;

push(node: default): void;

resolve(config?: Config): default;

findSchema(config?: Config): Schema | undefined;

transformAttributes(config?: Config): Record<string, any>;

transformChildren(config: Config): RenderableTreeNode[];

transform(config: Config): MaybePromise<RenderableTreeNodes>;

}

Referenced by

parse
resolve
transform
validate
tags
Ast
validator
default
ConfigType
Schema
Transformer
transform
fromJSON
Options

Function

decl source

export type Function = default

Variable

decl source

export type Variable = default

MaybePromise

decl source

export type MaybePromise<T> = T | Promise<T>

Referenced by

Node
Schema
Transformer

AstType

decl source

export interface AstType {

readonly $$mdtype: "Function" | "Node" | "Variable";

resolve(config: Config): any;

}

Referenced by

Ast
default
Node
Value
Function
Variable

AttributeValue

decl source

export type AttributeValue = {

type: string;

value: any;

}

Referenced by

Node

Config

decl source

export type Config = Readonly<ConfigType>

Referenced by

resolve
transform
validate
validator
default
Node
AstType
ConfigFunction
CustomAttributeTypeInterface
Schema
SchemaAttribute
Transformer
Function
Variable

ConfigType

decl source

export type ConfigType = Partial<{

nodes: Partial<Record<NodeType, Schema>>;

tags: Record<string, Schema>;

variables: Record<string, any>;

functions: Record<string, ConfigFunction>;

partials: Record<string, any>;

validation?: {

parents?: default[];

validateFunctions?: boolean;

environment?: string;

};

Referenced by

Config

ConfigFunction

decl source

export type ConfigFunction = {

returns?: ValidationType | ValidationType[];

parameters?: Record<string, SchemaAttribute>;

transform(parameters: Record<string, any>, config: Config): any;

validate(fn: default, config: Config): ValidationError[];

}

Referenced by

tags
functions
Ast
default
ConfigType

CustomAttributeTypeInterface

decl source

export interface CustomAttributeTypeInterface {

transform(value: any, config: Config): Scalar;

validate(value: any, config: Config, name: string): ValidationError[];

}

Referenced by

CustomAttributeType

CustomAttributeType

decl source

export interface CustomAttributeType {

new (): CustomAttributeTypeInterface;

readonly prototype: CustomAttributeTypeInterface;

}

Referenced by

ValidationType

Location

decl source

export type Location = {

file?: string;

start: LocationEdge;

end: LocationEdge;

}

Referenced by

Node
ValidationError
ValidateError

LocationEdge

decl source

export type LocationEdge = {

line: number;

character?: number;

}

Referenced by

Location

Referenced by

tags
Ast
default
Node
ConfigType

Primitive

decl source

export type Primitive = null | boolean | number | string

Referenced by

Scalar

RenderableTreeNode

decl source

export type RenderableTreeNode = default | Scalar

Referenced by

transform
Tag
default
Node
RenderableTreeNodes
Transformer

RenderableTreeNodes

decl source

export type RenderableTreeNodes = RenderableTreeNode | RenderableTreeNode[]

Referenced by

Node
Schema
Transformer
render
dynamic
reactStatic

Scalar

decl source

export type Scalar = Primitive | Scalar[] | {

[key: string]: Scalar;

}

Referenced by

CustomAttributeTypeInterface
RenderableTreeNode
Value

Schema

decl source

export type Schema<C extends Config = Config, R = string> = {

render?: R;

children?: string[];

attributes?: Record<string, SchemaAttribute>;

slots?: Record<string, SchemaSlot>;

selfClosing?: boolean;

inline?: boolean;

transform(node: default, config: C): MaybePromise<RenderableTreeNodes>;

validate(node: default, config: C): MaybePromise<ValidationError[]>;

description?: string;

}

Referenced by

tags
Ast
default
Node
ConfigType
Transformer
document
heading
paragraph
image
fence
blockquote
item
list
hr
table
td
th
tr
tbody
thead
strong
em
s
inline
link
code
text
hardbreak
softbreak
AttributesSchema

SchemaAttribute

decl source

export type SchemaAttribute = {

type?: ValidationType | ValidationType[];

render?: boolean | string;

default?: any;

required?: boolean;

matches?: SchemaMatches | ((config: Config) => SchemaMatches);

validate(value: any, config: Config, name: string): ValidationError[];

errorLevel?: ValidationError["level"];

description?: string;

}

Referenced by

default
ConfigFunction
Schema

SchemaMatches

decl source

export type SchemaMatches = RegExp | string[] | null

Referenced by

SchemaAttribute

SchemaSlot

decl source

export type SchemaSlot = {

render?: boolean | string;

required?: boolean;

}

Referenced by

Schema

Transformer

decl source

export interface Transformer {

findSchema(node: default, config: Config): Schema | undefined;

node(node: default, config: Config): MaybePromise<RenderableTreeNodes>;

attributes(node: default, config: Config): Record<string, any>;

children(node: default, config: Config): RenderableTreeNode[];

}

Referenced by

transformer
default

ValidationError

decl source

export type ValidationError = {

id: string;

level: "debug" | "info" | "warning" | "error" | "critical";

message: string;

location?: Location;

}

Referenced by

validator
Node
ConfigFunction
CustomAttributeTypeInterface
Schema
SchemaAttribute
ValidateError

ValidateError

decl source

export type ValidateError = {

type: string;

lines: number[];

location?: Location;

error: ValidationError;

}

Referenced by

validate
default

ValidationType

decl source

Referenced by

ConfigFunction
SchemaAttribute

Value

decl source

export type Value = AstType | Scalar

Referenced by

format

ParserArgs

decl source

export type ParserArgs = {

file?: string;

slots?: boolean;

location?: boolean;

}

Referenced by

parse

}