@mdfriday/foundry/dist/internal/domain/markdown/type.d.ts

The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.

import { Content } from "@internal/domain/markdown/vo/content";
export interface FrontMatterData {
    params: Record<string, any>;
    format: 'yaml' | 'toml' | 'json' | 'org';
}
export interface Shortcode {
    name: string;
    params: string[] | Record<string, any> | null;
    pos: number;
    length: number;
    rawContent: string;
    placeholder: string;
    inline: boolean;
    closed: boolean;
    inner?: string | any[];
    ordinal: number;
    indentation?: string;
    doMarkup: boolean;
}
export interface ParsedContentResult {
    frontMatter?: FrontMatterData | undefined;
    content: Content;
    shortcodes: Shortcode[];
    summary?: string;
    wordCount: number;
    readingTime: number;
}
export type ShortcodeRendererFunc = (shortcode: Shortcode) => Promise<string> | string;
export interface ContentResult {
    frontMatter?: Record<string, any>;
    renderedContent: string;
    summary?: string;
    wordCount: number;
    readingTime: number;
}
export interface RenderableDocument {
    frontMatter(): Record<string, any>;
    toc(): TocFragments;
    render(options: ParseAndRenderOptions): Promise<ContentResult>;
}
export interface ParseAndRenderOptions {
    shortcodeRenderer?: ShortcodeRendererFunc;
    maxSummaryLength?: number;
    wordsPerMinute?: number;
}
export interface Markdown extends Highlighter {
    render(rctx: RenderContext, dctx: DocumentContext): Promise<Result>;
    parseContent(source: Uint8Array): Promise<ParsedContentResult>;
    parseAndRenderContent(source: Uint8Array, options?: ParseAndRenderOptions): Promise<ContentResult>;
    prepareRender(source: Uint8Array): Promise<RenderableDocument>;
}
export interface Result extends RenderingResult, ParsingResult {
}
export interface ParsingResult {
    headers(): Header[];
    tableOfContents(): TocFragments;
}
export interface RenderingResult {
    bytes(): Uint8Array;
}
export interface Highlighter extends CodeBlockRenderer, IsDefaultCodeBlockRendererProvider {
    highlight(code: string, lang: string, opts?: any): Promise<string>;
    highlightCodeBlock(ctx: CodeblockContext, opts?: any): Promise<HighlightResult>;
}
export interface HighlightResult {
    wrapped(): string;
    inner(): string;
}
export interface AttributesOptionsSliceProvider {
    attributesSlice(): Attribute[];
    optionsSlice(): Attribute[];
}
export interface Attribute {
    name(): string;
    value(): any;
    valueString(): string;
}
export interface RenderContext {
    ctx: any;
    src: Uint8Array;
    renderTOC: boolean;
    getRenderer: GetRendererFunc;
}
export interface DocumentContext {
    document: any | null;
    documentID: string;
    documentName: string;
    filename: string;
}
export declare enum RendererType {
    LinkRendererType = 1,
    ImageRendererType = 2,
    HeadingRendererType = 3,
    CodeBlockRendererType = 4
}
export type GetRendererFunc = (t: RendererType, id?: any) => any | null;
export declare const DefaultRendererFunc: GetRendererFunc;
export interface ContextData {
    renderContext(): RenderContext;
    documentContext(): DocumentContext;
}
export interface TableOfContentsProvider {
    tableOfContents(): TocFragments;
}
export interface TocFragments {
    toHTML(startLevel: number, stopLevel: number, ordered: boolean): string;
}
export interface LinkContext {
    page(): any;
    destination(): string;
    title(): string;
    text(): RenderedString;
    plainText(): string;
}
export interface LinkRenderer {
    renderLink(cctx: any, w: FlexiWriter, ctx: LinkContext): Promise<void>;
}
export interface AttributesProvider {
    attributes(): Record<string, any>;
}
export interface HeadingContext extends AttributesProvider {
    page(): any;
    level(): number;
    anchor(): string;
    text(): RenderedString;
    plainText(): string;
}
export interface HeadingRenderer {
    renderHeading(cctx: any, w: FlexiWriter, ctx: HeadingContext): Promise<void>;
}
export interface IsDefaultCodeBlockRendererProvider {
    isDefaultCodeBlockRenderer(): boolean;
}
export interface ElementPositionResolver {
    resolvePosition(ctx: any): Position;
}
export interface Position {
    line: number;
    column: number;
    offset: number;
}
export interface CodeblockContext extends AttributesProvider, AttributesOptionsSliceProvider, Positioner {
    options(): Record<string, any>;
    type(): string;
    inner(): string;
    ordinal(): number;
    page(): any;
}
export interface Positioner {
    position(): Position;
}
export interface CodeBlockRenderer {
    renderCodeblock(cctx: any, w: FlexiWriter, ctx: CodeblockContext): Promise<void>;
}
export interface FlexiWriter {
    write(data: Uint8Array): Promise<void>;
    writeString(str: string): Promise<void>;
    writeByte(b: number): Promise<void>;
}
export type RenderedString = string;
export interface Header {
    name(): string;
    level(): number;
    links(): Link[];
    paragraphs(): Paragraph[];
    listParagraphs(): Paragraph[];
}
export interface Link {
    text(): string;
    url(): string;
}
export interface Paragraph {
    text(): string;
}
export interface MarkdownRenderer {
    render(source: string): Promise<string>;
    parse(source: string): Promise<ParsingResult>;
}
export interface MarkdownConfig {
    renderer?: MarkdownRenderer;
    extensions?: MarkdownExtension[];
    options?: Record<string, any>;
}
export interface MarkdownExtension {
    name: string;
    extend(md: any): void;
}
export type BasicMarkdownRenderFunc = (source: string) => Promise<string> | string;
export type BasicMarkdownParseFunc = (source: string) => Promise<any> | any;