Node.js – How to use a module when it could not find a declaration file

node.jsreactjstypescript

I have a typescript project using node.js. There is a module i want to use npm package country-code-lookup.

The problem is it does not have a supporting types declaration for it. However, i'd still like to use it.

Is it possible i could still use this package without the typings.

import * as CountryCodeLookup from "country-code-lookup";

   const countryCodes = CountryCodeLookup.countries;
   console.log(countryCodes);

I get the following error when typescript attempts to compile.

TS7016: Could not find a declaration file for module
'country-code-lookup'.
'/Users/kay/portal/node_modules/country-code-lookup/index.js'
implicitly has an 'any' type.
Try npm install @types/country-code-lookup if it exists or add a new declaration (.d.ts) file containing declare module 'country-code-lookup';

Best Answer

If you have no problems simply ignoring all type-checking features for this library, you have two options:

Add // @ts-ignore above all imports, like so:

// @ts-ignore
import * as CountryCodeLookup from "country-code-lookup";

Create a declaration file with any type, so all imports are automatically considered to be of any type.

To do so, create a file src/types/country-code-lookup/index.d.ts Add the following declaration:

// country-code-lookup/index.d.ts
declare module 'country-code-lookup';

In this file, later you can add your own type definitions. If they are good enough, push them do DefinitelyTyped, so all the community can use and improve it!

Related Solutions

Javascript – How to decide when to use Node.js

You did a great job of summarizing what's awesome about Node.js. My feeling is that Node.js is especially suited for applications where you'd like to maintain a persistent connection from the browser back to the server. Using a technique known as "long-polling", you can write an application that sends updates to the user in real time. Doing long polling on many of the web's giants, like Ruby on Rails or Django, would create immense load on the server, because each active client eats up one server process. This situation amounts to a tarpit attack. When you use something like Node.js, the server has no need of maintaining separate threads for each open connection.

This means you can create a browser-based chat application in Node.js that takes almost no system resources to serve a great many clients. Any time you want to do this sort of long-polling, Node.js is a great option.

It's worth mentioning that Ruby and Python both have tools to do this sort of thing (eventmachine and twisted, respectively), but that Node.js does it exceptionally well, and from the ground up. JavaScript is exceptionally well situated to a callback-based concurrency model, and it excels here. Also, being able to serialize and deserialize with JSON native to both the client and the server is pretty nifty.

I look forward to reading other answers here, this is a fantastic question.

It's worth pointing out that Node.js is also great for situations in which you'll be reusing a lot of code across the client/server gap. The Meteor framework makes this really easy, and a lot of folks are suggesting this might be the future of web development. I can say from experience that it's a whole lot of fun to write code in Meteor, and a big part of this is spending less time thinking about how you're going to restructure your data, so the code that runs in the browser can easily manipulate it and pass it back.

Here's an article on Pyramid and long-polling, which turns out to be very easy to set up with a little help from gevent: TicTacToe and Long Polling with Pyramid.

Javascript – the purpose of Node.js module.exports and how do you use it

module.exports is the object that's actually returned as the result of a require call.

The exports variable is initially set to that same object (i.e. it's a shorthand "alias"), so in the module code you would usually write something like this:

let myFunc1 = function() { ... };
let myFunc2 = function() { ... };
exports.myFunc1 = myFunc1;
exports.myFunc2 = myFunc2;

to export (or "expose") the internally scoped functions myFunc1 and myFunc2.

And in the calling code you would use:

const m = require('./mymodule');
m.myFunc1();

where the last line shows how the result of require is (usually) just a plain object whose properties may be accessed.

NB: if you overwrite exports then it will no longer refer to module.exports. So if you wish to assign a new object (or a function reference) to exports then you should also assign that new object to module.exports

It's worth noting that the name added to the exports object does not have to be the same as the module's internally scoped name for the value that you're adding, so you could have:

let myVeryLongInternalName = function() { ... };
exports.shortName = myVeryLongInternalName;
// add other objects, functions, as required

followed by:

const m = require('./mymodule');
m.shortName(); // invokes module.myVeryLongInternalName

Best Answer

Related Solutions

Javascript – How to decide when to use Node.js

Javascript – the purpose of Node.js module.exports and how do you use it

Related Topic