Question

我正在尝试为我们的项目创建工具。它由一个包含参与者列表的处理程序组成。当在响应中调度任何动作时，在仪器中间件中注册的所有参与者都将传递该动作以执行。

我想在一个模块中破坏此实现的所有类，并以这种方式引用它，这样就不需要单独导入类/接口。

问题是当我声明一个本地模块并尝试将其导入为模块时，没有编译错误。如果我使用模块中定义的任何接口，我都可以实现它，但是如果我尝试扩展该模块中定义的任何类，都会引发错误“找不到模块”

import * as A from 'instrumentation'
export class TestActor extends A.BaseActor {

    constructor(actorName: string) {
        super(actorName);
    }
}

错误-找不到模块：错误-无法解决检测问题

如果我改为尝试类似：-

export class TestActor implements A.ActionHandler {}

没有找到找不到模块的此类错误。我现在正在本地使用检测，但是稍后将其导出为库。

当前为此模块添加了custom_typings，并在tsconfig中指定了typeRoots。

以下所有类和接口：

declare module 'instrumentation' {

    export interface ActionHandler {
        (action: any): void;
    }

    export class BaseActor {

        constructor(actorName: string);
        //Map of action to all handlers for an action

        actionHandlers: Map<string, Array<ActionHandler>>;
        actorName: string;

        //Registers all handlers against the actions provided by the actor
        AddActions(actionName: string, actions : Array<string>, customHandler: ActionHandler);

        //Executes all the handlers for action in the sequence they are registered
        ExecuteHandler(action: any); 
    }

    export class InstrumentationHandler {

        //Array of actors available to middleware.
        _actors: Array<BaseActor>;

        constructor(instrumentationActors : Array<BaseActor>)

        // Middleware function to register against a store
        Middleware();

        //Passes action to each actor.
        public Handle(action:any)
    }
}

-InstrumentationHandler.ts

import { BaseActor } from './BaseActor';
export class InstrumentationHandler {
    //Array of actors available to middleware.
    _actors: Array<BaseActor> = new Array<BaseActor>();

    constructor(instrumentationActors : Array<BaseActor>) {
        if (instrumentationActors != null) {
            instrumentationActors.forEach(actor => this._actors.push(actor));
        }
    }

    // Middleware function to register against a store
    Middleware = store => next => action => {
        this.Handle(action);
        return next(action);
    }

    //Passes action to each actor.
    Handle = (action:any) => {
        this._actors.forEach(actor => actor.ExecuteHandler(action));
    }
}

-BaseActor.ts

import { ActionHandler } from "./ActionHandler"
export abstract class BaseActor {
    //Map of action to all handlers for an action
    actionHandlers: Map<string, Array<ActionHandler>>;
    actorName: string;

    constructor(actorName: string) {
        this.actorName = actorName;
        this.actionHandlers = new Map<string, Array<ActionHandler>>();
        this.AddActions.bind(this);
        this.ExecuteHandler.bind(this);
    }

    //Registers all handlers against the actions provided by the actor
    public AddActions(actionName: string, actions : Array<string>, customHandler: ActionHandler = null) {

    }

    //Executes all the handlers for action in the sequence they are registered
    public ExecuteHandler(action: any) {

    }
}

-- ActionHandler.ts
export interface ActionHandler {
    (action: any): void;
}

编写模块以公开新功能的所有类和接口

0 个答案: