bitran/dist/_types/process/factory.d.ts

📜 Highly customizable text processor and transpiler.

import { ProductType } from '../index.ts';
import { Node } from '../dom/node';
import { ProductNode } from '../dom/productNode';
import { BlocksNode, InlinersNode } from '../default/groups';
import { ProductCore } from '../core/product';
import { Range } from '../util/range';
import { ParseOptions, Parser } from './parse';
import { Stringifier, StrOptions } from './stringify';
export interface keyable extends Record<string, any> {
}
export declare abstract class ParseFactory<T extends ProductType = ProductType> {
    parser: Parser;
    parseOptions: ParseOptions;
    productNode: ProductNode<T>;
    abstract createParseData(...args: any[]): Promise<T['ParseData']>;
    getPayload(): {
        bitranCore: import('../core').BitranCoreConfig;
        productCore: ProductCore<T>;
        node: ProductNode<T>;
        parseData: T["ParseData"];
        provide: T["Provide"];
    };
    alterAutoId(autoId: string): string;
    parseBlocks(text: string): Promise<BlocksNode>;
    parseInliners(text: string): Promise<InlinersNode>;
}
export declare abstract class BlockParseFactory<T extends ProductType = ProductType> extends ParseFactory<T> {
    abstract canParse(strBlock: string): boolean;
    abstract createParseData(strBlock: string): Promise<T['ParseData']>;
}
export declare abstract class ObjBlockParseFactory<T extends ProductType = ProductType> extends BlockParseFactory<T> {
    abstract objName: string;
    abstract parseDataFromObj(obj: keyable, strBlock: string): Promise<T['ParseData']>;
    canParse(strBlock: string): boolean;
    createParseData(strBlock: string): Promise<T["ParseData"]>;
}
export declare abstract class InlinerParseFactory<T extends ProductType = ProductType> extends ParseFactory<T> {
    abstract outlineRanges(text: string): Range[];
    abstract createParseData(strInliner: string): Promise<T['ParseData']>;
}
export declare abstract class RegexpInlinerParseFactory<T extends ProductType = ProductType> extends InlinerParseFactory<T> {
    abstract regexp: RegExp;
    abstract parseDataFromRegexp(match: RegExpExecArray): Promise<T['ParseData']>;
    outlineRanges(text: string): Range[];
    createParseData(strInliner: string): Promise<T['ParseData']>;
}
export declare abstract class StrFactory<T extends Node = Node> {
    stringifier: Stringifier;
    strOptions: StrOptions;
    node: T;
    abstract stringifyNode(node: T): string;
    getPayload(): {
        node: T;
    };
    stringify(node: Node): string;
}
export declare abstract class ProductStrFactory<T extends ProductType = ProductType> extends StrFactory<ProductNode<T>> {
    abstract stringifyData(parseData: T['ParseData']): string;
    stringifyNode(node: ProductNode<T>): string;
}
export declare abstract class ObjProductStrFactory<T extends ProductType = ProductType> extends StrFactory<ProductNode<T>> {
    abstract objName: string;
    abstract createObj(parseData: T['ParseData']): keyable;
    stringifyNode(node: ProductNode<T>): string;
    static strObjBlock(objName: string, obj: keyable): string;
}
export type GenericProductStrFactory<T extends ProductType = ProductType> = ProductStrFactory<T> | ObjProductStrFactory<T>;