recogn-parse/dist/Resolver.d.ts

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

import { JudgeInfo } from "./Recognizer";
/**
 * 解析函数
 * @remarks
 * 对 target 进行解析
 *
 * @param target - 目标
 * @param targetOptions - 目标相关的选项
 * @param preResult - 之前的解析结果
 * @param recognResult - 识别结果
 * @returns 解析的结果
 */
export type Parse<Options = any> = (target: any, targetOptions: Options, preResult: any, recognResult: JudgeInfo) => any;
/**
 * 串行解析器
 *
 * @remarks
 * 串行解析器就是一组解析函数，这些解析函数会依次执行，并会以最后一个解析函数返回的结果为最终的解析结果。这组解析函数中如果有解析函数抛出错误，则会终止解决流程。
 */
export type SerialParser<Options = any> = Parse<Options>[];
/**
 * 解析器
 * @remarks
 * 解析器可以是一个解析函数，也可以是一组解析函数。
 * 当是一组解析函数时，所有的解析函数都会依次执行。并会以最后一个解析函数返回的结果为最终的解析结果。
 */
export type Parser<Options = any> = SerialParser<Options> | Parse<Options>;
/**
* 类型与解析器的映射
*/
export interface TypeParsers<Options = any> {
    /**
     * key 是类型，value 是串行解析器
     */
    [type: string]: SerialParser;
}
/**
 * 解析器集合
 * @remarks
 * 类型 与 解析器的 映射
 */
export interface TypeParsersOption<Options = any> {
    /**
     * key 是类型，value 是解析器
     */
    [type: string]: Parser<Options>;
}
/**
 * 解决者
 *
 * @remarks
 * 负责解析操作，所有的解析逻辑都是由该类来完成的。
 *
 * 每次执行解决操作时，会按照如下顺序调用解析器：
 *
 * 1. 如果找不到对应类型 type 的 解析器，则会终止解决流程。
 *
 * 2. 依次执行前置解析器 `preParses` 中的所有解析函数，即使有抛出错误，也会继续执行，并会以最后一个解析函数返回的结果为最终前置解析器的解析结果，然后将 前置解析的结果 传给后续的解析器。
 *
 * 3. 依次执行根据 类型 type 查找到的解析器序列。如果序列中任意解析器抛出错误，则会终止解决流程。否则，以最后一个解析函数返回的结果为最终的解析结果 并 传递给后续的解析器。
 *
 * 4. 依次执行后置解析器 `postParses` 中的所有解析函数，即使有抛出错误，也会继续执行，并会以最后一个解析函数返回的结果为最终的解析结果。
 */
export declare class Resolver<Options = any> {
    /**
     * 前置解析器
     * @remarks
     * 详情请看 {@link Resolver}
     */
    get preParses(): Parse<Options>[];
    set preParses(value: Parse<Options>[]);
    /**
     * @internal
     */
    protected _preParses?: Parse<Options>[] | null;
    /**
     * 后置解析器
     * @remarks
     * 详情请看 {@link Resolver}
     */
    get postParses(): Parse<Options>[];
    set postParses(value: Parse<Options>[]);
    /**
     * @internal
     */
    protected _postParses: Parse<Options>[];
    /**
     * 类型与解析器的映射
     */
    get typeParsers(): TypeParsers<any>;
    set typeParsers(value: TypeParsers<any>);
    /**
     * @internal
     */
    protected _typeParsers?: TypeParsers | null;
    /**
     * 添加解析器
     * @param type - 类型
     * @param parser - 解析器
     */
    add(type: string, parser: Parser<Options>): void;
    /**
     * 添加多个解析器
     * @param parsers - 类型 与 解析器的映射集合
     */
    addParsers(parsers: TypeParsersOption<Options>): void;
    /**
     * 删除 解析器
     * @param type - 类型
     * @param parser - 被删除的解析器
     * @returns 是否成功删除
     */
    remove(type: string, parser?: Parser<Options> | null): boolean;
    /**
     * 移除指定类型的解析器
     * @param type - 类型 或 类型列表
     * @returns
     */
    removeType(type: string[] | string): boolean;
    /**
     * 解决
     *
     * @remarks
     * 解决的过程请看 {@link Resolver}
     *
     * @param type - 类型
     * @param target - 目标
     * @param targetOptions - 目标相关的选项
     * @param recognResult - 识别结果
     * @returns
     */
    resolve(type: string, target: any, targetOptions?: any, recognResult?: any): any | Promise<any>;
    /**
     * 异步解决
     *
     * @remarks
     * 只有当最终有识别结果时，才会 resolve，否则，则会 reject。
     * 解决的过程请看 {@link Resolver}
     *
     * @param type - 类型
     * @param target - 目标
     * @param targetOptions - 目标相关的选项
     * @param recognResult - 识别结果
     * @returns
     */
    resolveAsync(type: string, target: any, targetOptions?: any, recognResult?: any): Promise<NonNullable<any>>;
}
//# sourceMappingURL=Resolver.d.ts.map