Imansible trovare un file di dichiarazione per il modulo ‘nome-modulo’. ‘/path/to/module-name.js’ ha implicitamente un tipo ‘qualsiasi’

Ho letto come funziona la risoluzione del modulo TypeScript.

Ho il seguente repository: ts-di . Dopo aver compilato la struttura della directory è il seguente:

├── dist │  ├── annotations.d.ts │  ├── annotations.js │  ├── index.d.ts │  ├── index.js │  ├── injector.d.ts │  ├── injector.js │  ├── profiler.d.ts │  ├── profiler.js │  ├── providers.d.ts │  ├── providers.js │  ├── util.d.ts │  └── util.js ├── LICENSE ├── package.json ├── README.md ├── src │  ├── annotations.ts │  ├── index.ts │  ├── injector.ts │  ├── profiler.ts │  ├── providers.ts │  └── util.ts └── tsconfig.json 

Nel mio package.json ho scritto "main": "dist/index.js" .

In Node.js tutto funziona bene, ma TypeScript:

 import {Injector} from 'ts-di'; 

Imansible trovare un file di dichiarazione per il modulo ‘ts-di’. ‘/path/to/node_modules/ts-di/dist/index.js’ ha implicitamente un tipo ‘qualsiasi’.

Eppure, se importassi come segue, allora tutto funziona:

 import {Injector} from '/path/to/node_modules/ts-di/dist/index.js'; 

Che cosa sto facendo di sbagliato?

Altri due modi, quando un modulo non è tuo – prova a installarlo da @types :

 npm install -D @types/module-name 

Oppure, se l’installazione è errata, provare a riscrivere l’ import per require :

 // import * as yourModuleName from 'module-name'; const yourModuleName = require('module-name'); 

Quella sensazione quando stai guardando da due giorni e la trovi così: basta rimuovere .js da "main": "dist/index.js" in package.json e tutto funziona bene!

 "main": "dist/index", 

UPD : questa risposta è relativa se hai il tuo pacchetto npm, se no – vedi la mia risposta qui sotto .

E se la risposta di cui sopra non è stata risolta, importa il tuo modulo, prova ad aggiungere typings in package.json :

 "main": "dist/index", "typings": "dist/index", 

Naturalmente, qui dist cartella – è dove memorizza i file del tuo modulo.

Se stai importando un modulo di terze parti 'foo' che non fornisce alcuna tipizzazione, né nella libreria stessa, né nel pacchetto @types/foo (generato dal repository DefinitelyTyped ), allora puoi fare in modo che questo errore si verifichi via dichiarando il modulo in un file .d.ts :

 // foo.d.ts declare module 'foo'; 

Quindi quando importi foo , verrà semplicemente digitato come any .


In alternativa, se vuoi eseguire i tuoi dattilografi, puoi farlo anche tu:

 // foo.d.ts declare module 'foo' { export function getRandomNumber(): number } 

Quindi questo verrà compilato correttamente:

 import { getRandomNumber } from 'foo'; const x = getRandomNumber(); // x is inferred as number 

Non è necessario fornire tipizzazioni complete per il modulo, quanto basta per i bit che si stanno effettivamente utilizzando (e si desidera una digitazione corretta), quindi è particolarmente facile da fare se si utilizza una quantità di API piuttosto ridotta.


D’altra parte, se non ti interessa la tipizzazione delle librerie esterne e vuoi che tutte le librerie senza digitazioni vengano importate come any , puoi aggiungerla a un file .d.ts :

 declare module '*'; 

Il vantaggio (e il lato negativo) di questo è che puoi importare assolutamente qualsiasi cosa e TS compilerà.

TypeScript sta fondamentalmente implementando regole e aggiungendo tipi al tuo codice per renderlo più chiaro e accurato a causa della mancanza di vincoli in Javascript. TypeScript richiede di descrivere i dati, in modo che il compilatore possa controllare il codice e trovare errori. Il compilatore ti informsrà se stai utilizzando tipi non corrispondenti, se sei fuori dal tuo ambito o se tenti di restituire un tipo diverso. Pertanto, quando si utilizzano librerie esterne e moduli con TypeScript, è necessario che contengano file che descrivono i tipi in tale codice. Questi file sono chiamati file di dichiarazione del tipo con un’estensione d.ts La maggior parte dei tipi di dichiarazione per i moduli npm sono già stati scritti e puoi includerli usando npm install @types/module_name (dove module_name è il nome del modulo di cui vuoi includere i tipi).

Tuttavia, ci sono moduli che non hanno le loro definizioni di tipo e per far sparire l’errore e importare il modulo usando import * as module_name from 'module-name' , crea una typings cartella nella root del tuo progetto, all’interno crea una nuova cartella con il nome del tuo modulo e in quella cartella crea un file module_name.d.ts e scrivi il declare module 'module_name' . Dopodiché accedi al tuo file tsconfig.json e aggiungi "typeRoots": [ "../../typings", "../../node_modules/@types"] nel compilerOptions (con il percorso relativo relativo a le tue cartelle) per consentire a TypeScript di sapere dove trovare le definizioni dei tipi delle tue librerie e moduli e aggiungere una nuova proprietà "exclude": ["../../node_modules", "../../typings"] a il file. Ecco un esempio di come dovrebbe apparire il tuo file tsconfig.json:

 { "compilerOptions": { "module": "commonjs", "noImplicitAny": true, "sourceMap": true, "outDir": "../dst/", "target": "ESNEXT", "typeRoots": [ "../../typings", "../../node_modules/@types" ] }, "lib": [ "es2016" ], "exclude": [ "../../node_modules", "../../typings" ] } 

In questo modo, l’errore andrà via e sarai in grado di attenersi alle ultime regole ES6 e TypeScript.

Ho risolto questo problema solo facendo questo:

 import * as foo from "foo"; 

Nel mio caso, questo problema si è verificato durante il tentativo di utilizzare la class predefinita esportata da una libreria.

Ho avuto lo stesso problema e l’ho risolto aggiornando il tsconfig.json di tsconfig.json questo modo:

 { "compilerOptions": { ... "noImplicitAny": false, ... }, "exclude": [ ... ] }