@diplodoc/transform/lib/typings.d.ts

A simple transformer of text in YFM (Yandex Flavored Markdown) to HTML

import { LanguageFn } from 'highlight.js';
import DefaultMarkdownIt, { Token } from 'markdown-it';
import DefaultStateCore from 'markdown-it/lib/rules_core/state_core';
import { SanitizeFunction, SanitizeOptions } from './sanitize';
import { LogLevels, Logger } from './log';
import { ChangelogItem } from './plugins/changelog/types';
export interface MarkdownIt extends DefaultMarkdownIt {
    assets?: string[];
    meta?: string[];
}
export interface StateCore extends DefaultStateCore {
    md: MarkdownIt;
}
export interface CacheContext {
    get(key: string): string | null | undefined;
    set(key: string, value: string | null | undefined): void;
}
export declare type HighlightLangMap = Record<string, LanguageFn>;
export declare type Heading = {
    title: string;
    href: string;
    level: number;
    items?: Heading[];
};
export interface OptionsType {
    tokens?: boolean;
    vars?: Record<string, string>;
    path?: string;
    extractTitle?: boolean;
    needTitle?: boolean;
    allowHTML?: boolean;
    linkify?: boolean;
    linkifyTlds?: string | string[];
    breaks?: boolean;
    conditionsInCode?: boolean;
    disableLiquid?: boolean;
    leftDelimiter?: string;
    rightDelimiter?: string;
    isLiquided?: boolean;
    needToSanitizeHtml?: boolean;
    sanitizeOptions?: SanitizeOptions;
    sanitize?: SanitizeFunction;
    needFlatListHeadings?: boolean;
    plugins?: ExtendedPluginWithCollect<any, any>[];
    preprocessors?: MarkdownItPreprocessorCb[];
    highlightLangs?: HighlightLangMap;
    disableRules?: string[];
    extractChangelogs?: boolean;
    root?: string;
    rootPublicPath?: string;
    transformLink?: (href: string) => string;
    getPublicPath?: (options: OptionsType, href?: string) => string;
    renderInline?: boolean;
    cache?: CacheContext;
    /**
     * `markdown-it-attrs` plugin is enabled by default
     *
     * Set value to `false` to disable it
     */
    enableMarkdownAttrs?: boolean;
    [x: string]: unknown;
}
export interface OutputType {
    result: {
        html: string;
    } & EnvType;
    logs: Record<LogLevels, string[]>;
}
export declare type EnvType<Extras extends {} = {}> = {
    title?: string;
    headings: Heading[];
    assets?: unknown[];
    meta?: object;
    changelogs?: ChangelogItem[];
    additionalOptionsCssWhiteList?: CssWhiteList;
} & Extras;
export interface MarkdownItPluginOpts {
    path: string;
    log: Logger;
    lang: 'ru' | 'en' | 'es' | 'fr' | 'cs' | 'ar' | 'he';
    root: string;
    rootPublicPath: string;
    isLintRun: boolean;
    cache?: CacheContext;
    conditionsInCode?: boolean;
    vars?: Record<string, string>;
    extractTitle?: boolean;
    disableLiquid?: boolean;
    skipLinkFileCheck?: boolean;
}
export declare type MarkdownItPluginCb<T extends {} = {}> = {
    (md: MarkdownIt, opts: T & MarkdownItPluginOpts): void;
};
export declare type IntrinsicCollectOptions = {
    tokenStream: Token[];
};
export declare type ExtendedPluginWithCollect<PluginRegularOptions extends {} = {}, PluginCollectOptions = {}> = MarkdownItPluginCb<PluginRegularOptions> & {
    collect?: (input: string, options: PluginCollectOptions & IntrinsicCollectOptions) => string | void;
};
export declare type MarkdownItPreprocessorCb<T extends unknown = {}> = {
    (input: string, opts: T & Partial<MarkdownItPluginOpts>, md?: MarkdownIt): string;
};
export declare type CssWhiteList = {
    [property: string]: boolean;
};