无法将JavaScript注入模式转换为TypeScript

Question

We use a bespoke injection pattern in a rather large vanilla JavaScript application (more a framework with many consumers). The pattern allows us to be explicit about what dependencies each JS module takes. This is beneficial for two main reasons: it is easy to stub dependencies when unit testing a module and it allows our consumers to dynamically replace module implementations at runtime.

We have started migrating all of our modules over to TypeScript but have run into trouble converting a few modules that expose custom types. The problem is that TypeScript seems to want custom types to be exported immediately but we actually want to export the type after supplying the runtime dependencies via a function call (our dependency injection pattern).

So the question is how can we convert the following injection pattern to TypeScript without compromising the pattern itself?

 module.exports = function ContextModule(logger) { var log = logger.register('context'); function Context() { log('creating type'); } Context.prototype = { doSomething: function() { log('doing something'); } } Context.doSomethingStatic = function() { log('doing something static'); } return Context; }; 

We return the custom type and can then new it up when we need to. For example, we might compose the above highly contrived module in a main.js as follows:

 var loggerModule = require('LoggerModule.js'); var contextModule = require('ContextModule.js'); logger = loggerModule(); var Context = contextModule(logger); // then we might use the Context type var context = new Context(); context.doSomething(); // instance method Context.doSomethingStatic(); // static method 

Note the following:

• the logger module is injected into the context module
• the logger module methods are then used in the ContextModule function directly or in the "class" implementation it is defining
• we use CommonJs to "require in" the module files and browserify to combine them

Answer 1

So the question is how can we convert the following injection pattern to TypeScript without compromising the pattern itself

You can definitely use it as it is (JavaScript is valid TypeScript). If you want safety, the process to convert the injection framework to TypeScript idioms is going to be more hard than just using one designed for it.

I highly recommend https://github.com/inversify/InversifyJS