Impossible de trouver un fichier de déclaration pour le module 'nom-module'. '/path/to/module-name.js' a implicitement un type 'any'

J'ai lu comment fonctionne la résolution du module TypeScript .

J'ai le référentiel suivant: @ ts-stack / di . Après avoir compilé la structure du répertoire est la suivante:

├── 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

Dans mon package.json, j'ai écrit "main": "dist/index.js".

Dans Node.js, tout fonctionne bien, mais TypeScript:

import {Injector} from '@ts-stack/di';

Impossible de trouver un fichier de déclaration pour le module '@ ts-stack / di'. '/path/to/node_modules/@ts-stack/di/dist/index.js' a implicitement un type 'any'.

Et pourtant, si j'importe comme suit, alors tout fonctionne:

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

Qu'est-ce que je fais mal?

Voici deux autres solutions

Lorsqu'un module n'est pas le vôtre, essayez d'installer des types à partir de @types:

npm install -D @types/module-name

Si les erreurs d'installation ci-dessus - essayez de changer les importinstructions pour require:

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

Si vous importez un module tiers 'foo'qui ne fournit aucune saisie, ni dans la bibliothèque elle-même, ni dans le @types/foopackage (généré à partir du référentiel DefinitelyTyped ), vous pouvez faire disparaître cette erreur en déclarant le module dans un fichier avec une .d.tsextension. TypeScript recherche les .d.tsfichiers aux mêmes endroits qu'il recherchera les .tsfichiers normaux : comme spécifié sous "fichiers", "inclure" et "exclure" dans le tsconfig.json.

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

Ensuite, lorsque vous importez, fooil sera simplement saisi comme any.

Alternativement, si vous voulez rouler vos propres dactylographies, vous pouvez aussi le faire:

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

Ensuite, cela se compilera correctement:

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

Vous n'avez pas à fournir des typages complets pour le module, juste assez pour les bits que vous utilisez réellement (et souhaitez des typages appropriés), il est donc particulièrement facile de le faire si vous utilisez une assez petite quantité d'API.

D'un autre côté, si vous ne vous souciez pas des typages des bibliothèques externes et souhaitez que toutes les bibliothèques sans typage soient importées en tant que any, vous pouvez l'ajouter à un fichier avec une .d.tsextension:

declare module '*';

L'avantage (et l'inconvénient) de cela est que vous pouvez importer n'importe quoi et que TS compilera.

Si vous avez besoin d'une solution rapide, ajoutez-la simplement avant la ligne de votre importation:

// @ts-ignore

Ce sentiment quand vous êtes à la recherche pendant deux jours et trouvez comme ceci: il suffit de retirer .jsde "main": "dist/index.js"dans package.jsonet tout fonctionne bien!

"main": "dist/index",

UPD : cette réponse est relative si vous avez votre propre package npm, sinon - voir ma réponse ci-dessous .

Et si la réponse ci - dessus pas résolu l' importation de votre module, essayez d' ajouter typingsdans package.json:

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

Bien sûr, ici le dossier dist- c'est où stocke les fichiers de votre module.

TypeScript implémente essentiellement des règles et ajoute des types à votre code pour le rendre plus clair et plus précis en raison de l'absence de contraintes dans Javascript. TypeScript vous oblige à décrire vos données, afin que le compilateur puisse vérifier votre code et trouver des erreurs. Le compilateur vous indiquera si vous utilisez des types incompatibles, si vous êtes hors de votre portée ou si vous essayez de renvoyer un type différent. Ainsi, lorsque vous utilisez des bibliothèques et des modules externes avec TypeScript, ils doivent contenir des fichiers décrivant les types de ce code. Ces fichiers sont appelés fichiers de déclaration de type avec une extension d.ts. La plupart des types de déclaration pour les modules npm sont déjà écrits et vous pouvez les inclure en utilisant npm install @types/module_name(où nom_module est le nom du module dont vous voulez inclure les types).

Cependant, il existe des modules qui n'ont pas leurs définitions de type et afin de faire disparaître l'erreur et d'importer le module en utilisant import * as module_name from 'module-name', créez un dossier typingsà la racine de votre projet, à l'intérieur créez un nouveau dossier avec le nom de votre module et dans ce dossier créer un module_name.d.tsfichier et écrire declare module 'module_name'. Après cela, allez simplement dans votre tsconfig.jsonfichier et ajoutez- "typeRoots": [ "../../typings", "../../node_modules/@types"]le compilerOptions(avec le chemin d'accès approprié à vos dossiers) pour indiquer à TypeScript où il peut trouver les définitions de types de vos bibliothèques et modules et ajouter une nouvelle propriété "exclude": ["../../node_modules", "../../typings"]au fichier. Voici un exemple de l'apparence de votre fichier tsconfig.json:

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

Ce faisant, l'erreur disparaîtra et vous pourrez vous en tenir aux dernières règles ES6 et TypeScript.

Pour toute autre personne lisant ceci, essayez de renommer votre fichier .js en .ts

Modifier: vous pouvez également ajouter "allowJs": trueà votre fichier tsconfig.

Cela fonctionne pour moi:

declare module 'Injector';

  {
    "compilerOptions": {
        "strictNullChecks": true,
        "moduleResolution": "node",
        "jsx": "react",
        "noUnusedParameters": true,
        "noUnusedLocals": true,
        "allowSyntheticDefaultImports":true,
        "target": "es5",
        "module": "ES2015",
        "declaration": true,
        "outDir": "./lib",
        "noImplicitAny": true,
        "importHelpers": true
      },
      "include": [
        "src/**/*",
        "index.d.ts",   // declaration file path
      ],
      "compileOnSave": false
    }

- modifier: les guillemets nécessaires autour du nom du module

J'ai eu le même problème en utilisant un module de noeud avec une application de réaction écrite en tapuscrit. Le module a été installé avec succès à l'aide de npm i --save my-module. Il est écrit en javascript et exporte une Clientclasse.

Avec:

import * as MyModule from 'my-module';
let client: MyModule.Client = new MyModule.Client();

La compilation échoue avec l'erreur:

Could not find a declaration file for module 'my-module'. 
'[...]/node_modules/my-module/lib/index.js' implicitly has an 'any' type.
  Try `npm install @types/my-module` if it exists or add a new declaration (.d.ts) file containing `declare module 'my-module';`

@types/my-modulen'existe pas, j'ai donc ajouté un my-module.d.tsfichier à côté de celui où my-moduleest importé, avec la ligne suggérée. J'ai alors eu l'erreur:

Namespace '"my-module"' has no exported member 'Client'.

Le client est en fait exporté et fonctionne normalement si je l'utilise dans une application js. En outre, le message précédent m'indique que le compilateur recherche dans le bon fichier ( /node_modules/my-module/lib/index.jsest défini dans l' my-module/package.json "main"élément).

J'ai résolu le problème en disant au compilateur que je m'en fichais implicitement any, c'est-à-dire que je définissais falsela ligne suivante du tsconfig.jsonfichier:

    "noImplicitAny": false,

simple à réparer est:

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

si vous voulez déclarer l'interface d'objet (recommandé pour un grand projet) vous pouvez utiliser:

// example.d.ts
declare module 'foo'{
    // example
    export function getName(): string
}

Comment l'utiliser? Facile..

const x = require('foo') // or import x from 'foo'
x.getName() // intellisense can read this

J'obtenais cela aussi, m'avait dérouté pendant un certain temps, même avec le module et les types déjà installés et en rechargeant plusieurs fois mon IDE.

Dans mon cas, ce qui a résolu le problème était de mettre fin aux processus terminaux, de supprimer node_modules, de vider le cache du gestionnaire de packages de nœuds et de faire un nouveau installchargement, puis de recharger l'éditeur.

Malheureusement, il n'est pas de notre ressort si l'auteur du paquet dérange avec un fichier de déclaration. Ce que j'ai tendance à faire, c'est d'avoir un fichier index.d.tsqui contiendra tous les fichiers de déclaration manquants de divers packages:

Index.ts:

declare module 'v-tooltip';
declare module 'parse5';
declare module 'emoji-mart-vue-fast';

C'est ce qui a fonctionné de moi.

npm install --save readline

J'ai tout essayé ici, mais pour moi, c'était un problème complètement différent: j'ai dû supprimer de mes *.d.tsdéclarations d'importation:

import { SomeModuleType } from '3rd-party-module';

Après avoir supprimé l'erreur est parti ...

Clarification : lorsque nous déclarons un module dans un *.d.tsfichier, il est automatiquement récupéré par le compilateur Typescript en tant que module ambiant (celui que vous n'avez pas besoin d'importer explicitement). Une fois que nous avons spécifié le import ... from ..., le fichier devient maintenant un module normal (ES6), et ne sera donc pas récupéré automatiquement. Par conséquent, si vous souhaitez qu'il se comporte comme un module ambiant , utilisez un style d'importation différent comme ceci:

type MyType: import('3rd-party-module').SomeModuleType;

Vous pouvez simplement l'importer en utilisant require comme code suivant:

var _ = require('your_module_name');