recogn-parse/dist/index.d.ts

recogn-parse 提供了 识别--解析 的机制，使用者只需要添加识别器 和 解析器，然后就可以对事件进行识别和解析，适合用所有具备 识别--解析 流程的场景中，如：加载并显示各种模型、预览文件等

/**
 * 识别解析
 *
 * @remarks
 * 这是一个 `识别—解析` 工具，用户可以注册识别器 和 解析器，对于输入资源，它会先用用注册的识别器进行识别，识别出类型之后，再调用用户注册的对应类型的解析器进行解析，这是它的基本机制，同时它具备一些更具通用性、扩展性、复用性 和 易用性 的机制，比如：支持前置识别器、后置识别器、前置解析器、后置解析器、一进多出、异步识别、异步解析 等等。
 *
 * @packageDocumentation
 */
import { Recognizer, FormatJudgeResult, JudgeInfo, Judger, RecognResult } from "./Recognizer";
import { Resolver, Parser } from "./Resolver";
export * from "./Recognizer";
export * from "./Resolver";
/**
 * 识别解析出的信息
 */
export interface ParseInfo {
    /**
     * 识别出的信息
     */
    recogn: JudgeInfo;
    /**
     * 解析出的信息
     */
    parse: any;
}
/**
 * 识别解析信息的集合
 * @remarks
 * 是 类型 和 识别解析出的信息的映射
 */
export interface RecognParseInfo {
    /**
     * key 是类型，value 是识别和解析的信息
     */
    [type: string]: ParseInfo;
}
/**
 * 识别解析的结果
 * @remarks
 * 可以是同步 或 异步的 识别解析信息的集合
 */
export type RecognParseResult = RecognParseInfo | null | Promise<RecognParseInfo | null>;
/**
 * 异步识别解析的结果
 */
export type RecognParseResult_Async = Promise<RecognParseInfo>;
/**
 * 鉴定器和解析器对
 */
export interface RecognParser<Options = any> {
    judger?: Judger<Options> | null;
    parser?: Parser<Options> | null;
}
/**
 * 识别解析选项
 */
export interface TypeRecognParsers<Options = any> {
    /**
     * key 是类型，value 是 鉴定器和解析器对
     */
    [type: string]: RecognParser<Options>;
}
/**
 * resolve 方法的选项
 */
export interface ResolveOptions {
    /**
     * 指定的类型
     */
    type?: string | null;
    /**
     * 指定鉴定器的名字
     */
    recogn?: string | null;
    /**
     * 指定解析的类型
     */
    parse?: string | null;
    /**
     * 跳过识别
     */
    noRecogn?: boolean | null;
}
/**
 * 识别解析
 * @remarks
 * 是用户直接操作的主类，提供了完整的 `识别-解析` 机制
 */
export declare class RecognParse<TOptions = any> {
    /**
     * @internal
     */
    protected _recognizer?: Recognizer<TOptions> | null;
    /**
     * 识别器
     */
    get recognizer(): Recognizer<TOptions>;
    set recognizer(value: Recognizer<TOptions>);
    /**
     * 前置鉴定器
     */
    get preJudgers(): Judger<TOptions>[];
    set preJudgers(value: Judger<TOptions>[]);
    /**
     * 后置鉴定器
     */
    get postJudgers(): Judger<TOptions>[];
    set postJudgers(value: Judger<TOptions>[]);
    /**
     * @internal
     */
    protected _resolver?: Resolver<TOptions> | null;
    /**
     * 解决者
     */
    get resolver(): Resolver<TOptions>;
    set resolver(value: Resolver<TOptions>);
    /**
     * 前置解析器
     */
    get preParses(): import("./Resolver").Parse<TOptions>[];
    set preParses(value: import("./Resolver").Parse<TOptions>[]);
    /**
     * 后置解析器
     */
    get postParses(): import("./Resolver").Parse<TOptions>[];
    set postParses(value: import("./Resolver").Parse<TOptions>[]);
    /**
     * 给指定类型添加鉴定解析器
     * @param type - 类型
     * @param judgerParser - 包含鉴定器 和 解析器
     */
    add(type: string, judgerParser: RecognParser<TOptions>): void;
    /**
     * 批量添加鉴定解析器
     * @param recognParsers - 类型 和 鉴定器和解析器对的映射
     */
    addRecognParsers(recognParsers: TypeRecognParsers<TOptions>): void;
    /**
     * 移除指定类型的鉴定器和解析器
     * @param type - 类型
     */
    remove(type: string[] | string): void;
    /**
     * {@inheritDoc ./Recognizer#Recognizer.recogn}
     */
    recogn(target: any, targetOptions?: any, name?: string | null): RecognResult;
    /**
     * {@inheritDoc ./Recognizer#Recognizer.recognAsync}
     */
    recognAsync(target: any, targetOptions?: any, name?: string | null): Promise<JudgeInfo[]>;
    /**
     * 识别并解析 target
     *
     * @param target - 识别解析的目标
     * @param targetOpts - 目标选项，主要包含的是与目标相关的选项，大多数场景可能是服务于解析目标的，往往不同类型的目标会有不同的选项，
     * @param options - resolve 方法本身的选项，用于控制 识别解析过程的，而不是控制针对目标的具体的鉴定、解析逻辑的，通常与目标无关。
     */
    resolve(target: any, targetOpts: TOptions, options?: ResolveOptions | null): RecognParseResult;
    /**
     * 异步识别并解析
     *
     * @remarks
     * 只有当最终有识别结果时，才会 resolve，否则，则会 reject
     *
     * @param target - 识别解析的目标
     * @param targetOpts - 目标选项，主要包含的是与目标相关的选项，大多数场景可能是服务于解析目标的，往往不同类型的目标会有不同的选项，
     * @param options - resolve 方法本身的选项，用于控制 识别解析过程的，而不是控制针对目标的具体的鉴定、解析逻辑的，通常与目标无关。
     */
    resolveAsync(target: any, targetOpts: TOptions, options?: ResolveOptions | null): RecognParseResult_Async;
    /**
     * 解析识别的结果
     * @param judgeResult - 识别的结果
     * @param target - 目标
     * @param targetOptions - 目标选项，主要包含的是与目标相关的选项，大多数场景可能是服务于解析目标的，往往不同类型的目标会有不同的选项，
     */
    parse(judgeResult: FormatJudgeResult, target: any, targetOptions: TOptions): RecognParseInfo | null;
}
//# sourceMappingURL=index.d.ts.map