recogn-parse/dist/Recognizer.d.ts

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

/**
 * 鉴定函数
 * @remarks
 * 鉴定 target 的类型 和 格式化数据，如果返回 空，表示鉴定失败
 *
 * @param target - 目标
 * @param targetOptions - 目标相关的选项
 * @param preResult - 上一个鉴定函数的鉴定结果
 * @returns 返回鉴定结果，可以是异步的鉴定结果；鉴定结果是可以是 一个 或 一组 鉴定信息 {@link JudgeInfo}，也可以是空，如果是空 表示鉴定失败
 */
export type Judge<Options = any> = (target: any, targetOptions: Options, preResult: FormatJudgeResult) => JudgeReturn;
/**
 * 串行鉴定者
 *
 * @remarks
 * 串行鉴定者就是一组鉴定函数，所有的鉴定函数都会依次执行，不论中间有没有失败，都会依次执行完所有的鉴定函数，并会以最后一个鉴定函数返回的结果为最终的鉴定结果。
 * 串行鉴定者序列中的任何项识别失败都不会中止 串行鉴定者序列 的执行。
 * 即：即使 串行鉴定者序列 SerialJudger 中的某一个 Judge 返回 null 或者 抛出错误，则仍会执行此 串行鉴定者序列 SerialJudger 中的下一个 Judge
 */
export type SerialJudger<Options = any> = Judge<Options>[];
/**
 * 鉴定者
 *
 * @remarks
 * 表示可以用作为一次独立鉴定的鉴定者。如果最终返回值为空，则表示鉴定失败；如果最终返回的有鉴定信息 {@link JudgeInfo}，则表示鉴定成功
 */
export type Judger<Options = any> = SerialJudger<Options> | Judge<Options>;
/**
 * 鉴定信息
 */
export interface JudgeInfo {
    /**
     * 鉴定出来的类型
     */
    type: string;
    /**
     * 内容数据
     */
    content?: any;
}
/**
 * 鉴定结果
 *
 * @remarks
 * 表示鉴定的最终结果，空值 表示鉴定失败，非空的值 表示鉴定出来的鉴定信息，可以是多个鉴定信息
 */
export type JudgeResult = JudgeInfo[] | JudgeInfo | null | undefined;
/**
 * 格式化后的鉴别结果
 *
 * @remarks
 * 没有鉴定出来的 返回  null
 * 识别出来的，返回 {@link JudgeInfo} 类型的数组，且至少有一个元素
 */
export type FormatJudgeResult = JudgeInfo[] | null;
/**
 * 监定函数的返回值的类型
 * @remarks
 * 可以是同步的结果 {@link JudgeResult} 也可以是异步的 `Promise<JudgeResult>`
 */
export type JudgeReturn = Promise<JudgeResult> | JudgeResult;
/**
 * 命名的串行监定者集合
 * @remarks
 * 名字 与 串行鉴定者 的映射
 */
export interface NamedSerialJudgers<Options = any> {
    /**
     * key 是名字，value 是串行鉴定者
     */
    [name: string]: SerialJudger<Options>;
}
/**
* 命名的监定者集合
* @remarks
* 名字 与 串行鉴定者 的映射
*/
export interface NamedJudgers<Options = any> {
    /**
     * key 是名字，value 是串行鉴定者
     */
    [name: string]: Judger<Options>;
}
/**
 * 识别结果
 * @remarks
 * 可以是同步的 格式化后的 {@link FormatJudgeResult} 鉴定结果，也可以是 异步的 `Promise<FormatJudgeResult>`
 */
export type RecognResult = Promise<FormatJudgeResult> | FormatJudgeResult;
/**
 * 识别器
 *
 * @remarks
 * 负责识别操作，所有的识别逻辑都是由该类来完成的。
 *
 * 每次执行识别操作时，会按照如下顺序调用鉴定者：
 *
 * 1. 依次执行前置鉴定者列表 `preJudgers` 中的鉴定者，如果有鉴定成功的，则会停止后续的前置鉴定者的执行，并将鉴定结果 传给后续流程。
 *
 * 2. 如果提供了 name，则会在 命名的鉴定者 中查找 name 对应的鉴定者，然后执行指定的鉴定者。然后 跳到 步骤 5。
 *
 * 3. 如果没有提供 name，则会执行 匿名的鉴定者列表。如果有鉴定结果，则会 跳到 步骤 5。
 *
 * 4. 否则，则会执行 所有的命名鉴定者。如果有鉴定结果，则会 跳到 步骤 5。
 *
 * 5. 依次执行后置鉴定者列表 `postJudgers` 中的鉴定者，如果有鉴定成功的，则会停止后续的后置鉴定者的执行，并返回 鉴定结果。否则返回 空；
 */
export declare class Recognizer<Options = any> {
    /**
     * 前置鉴定者
     */
    get preJudgers(): Judger<Options>[];
    set preJudgers(value: Judger<Options>[]);
    /**
     * @internal
     */
    protected _preJudgers: Judger<Options>[];
    /**
     * 后置鉴定者
     */
    get postJudgers(): Judger<Options>[];
    set postJudgers(value: Judger<Options>[]);
    /**
     * @internal
     */
    protected _postJudgers: Judger<Options>[];
    /**
     * 命名的鉴定者
     * @remarks
     * namedJudgers 中的识别顺序是按照加入 namedJudgers 中时的顺序来识别的
     *
     * namedJudgers {@link Recognizer.namedJudgers} 的优先级低于 judgers {@link Recognizer.judgers}，即：
     * 会先执行 judgers 中的识别器，如果不能识别，再执行 namedJudgers 中的识别器
     */
    readonly namedJudgers: Map<string, SerialJudger<Options>>;
    /**
     * 匿名的鉴定者列表
     *
     * @remarks
     * namedJudgers {@link Recognizer.namedJudgers} 的优先级低于 judgers {@link Recognizer.judgers}，即：
     * 会先执行 judgers 中的识别器，如果不能识别，再执行 namedJudgers 中的识别器
     */
    readonly judgers: Judger<Options>[];
    /**
     * 所有的鉴定者
     */
    get allJudgers(): Judger<Options>[];
    /**
     * 添加鉴定者
     * @param judge - 鉴定者
     * @param name - 鉴定者的名字
     */
    add(judge: Judger<Options>, name?: string | null): void;
    /**
     * 添加多个鉴定者
     * @param judgers - 鉴定者列表 或 名字与鉴定者的映射
     */
    addJudgers(judgers: Judger<Options>[] | NamedJudgers<Options>): void;
    /**
     * 移除指定名字的鉴定者
     * @param name - 鉴定者的名字
     * @returns 返回值表示 是否移除成功
     */
    removeByName(name: string[] | string): boolean;
    /**
     * 删除 指定的 judger
     *
     * @remarks
     * 当 judger 为 数组类型时，会把其作为 SerialJudger 来对象，不会对 SerialJudger 中包含的 各个 Judge 进行单独查找与删除
     *
     * @param judger - 鉴定者
     * @returns 表示是否移除成功
     */
    remove(judger: Judger<Options>): boolean;
    /**
     * 批量删除
     *
     * @remarks
     * 会先按照 {@link Recognizer.remove} 的逻辑进行删除，如果删除不成功，则会把 judges 或 其包含的 所有 Judge 进行单独查找与删除，也会在 SerialJudger 的元素中进行查找与删除
     *
     * @param judges
     * @returns 表示是否成功移除
     */
    removeJudges(judges: Judger<Options>): boolean;
    /**
     * 识别目标
     *
     * @remarks
     * 具体的执行逻辑请看 {@link Recognizer}
     *
     * @param target - 目标
     * @param targetOptions - 目标选项
     * @param name - 鉴定者的名字
     *
     * @return 返回的结果可能是同步的，也可能是异步的
     */
    recogn(target: any, targetOptions?: any, name?: string | null): RecognResult;
    /**
     * 异步识别
     *
     * @remarks
     * 只有当最终有识别结果时，才会 resolve，否则，则会 reject。
     * 具体的执行逻辑请看 {@link Recognizer}
     *
     * @param target - 目标
     * @param targetOptions - 目标选项
     * @param name - 鉴定者的名字
     */
    recognAsync(target: any, targetOptions?: any, name?: string | null): Promise<JudgeInfo[]>;
}
//# sourceMappingURL=Recognizer.d.ts.map