node.js - Importering af typescript fra eksterne node-moduler

Jeg vil opdele min applikation i forskellige node-moduler og have et hovedmodul, som bygger alle andre moduler, og jeg vil bruge TypeScript med ES6-moduler.

Her er min planlagte projektstruktur:

  • hoved

    • node_modules

      • dep-a

      • node_modules
      • dep-a

      • dep-b

  • rammeværk

    • grænseflader

      • IComponent.ts

      • interfaces
      • IComponent.ts

  • dep-a

    • komponenter

      • test.ts

      • komponenter
      • test.ts

    • node_modules

      • rammeværk
    • index.ts

  • dep-b

    • node_modules

      • rammeværk

      • node_modules
      • rammeværk

Jeg vil være i stand til at definere interfaces i frameworket, som kan bruges i dep-a, dep-b og main.

Hvordan sætter jeg dette korrekt op? Kan jeg kompilere alt fra mit hovedmodul? Skal jeg oprette forskellige bundter for framework, dep-a, ... og en anden typningsfil? Hvad er den bedste fremgangsmåde for dette?

Jeg har allerede opsat nogle testfiler og mapper og brugt npm link til at linke afhængighederne og webpack til at bundle filerne, og jeg støder altid på problemer med, at filer ikke findes:

error TS2307: Cannot find module 'framework/interfaces/IComponent'

og

Module not found: Error: Cannot resolve 'file' or 'directory' ./components/test

Svar #1

TL;DR generer deklarationer for modulerne ved at bruge declaration: true i tsconfig.json og angiv filen for dine genererede typing-filer i typings-indgangen i package.json-filen

rammeværk

Brug en tsconfig-fil, der ligner denne:

{
       "compilerOptions": {
        "target": "es5",
        "module": "commonjs",
        "declaration": true,
        "noImplicitAny": true,
        "removeComments": true,
        "outDir": "dist",
        ...
    },
    "files": [
         ...
    ]
}

Det vigtige er declaration: true, som vil generere interne deklarationer i dist-mappen

Forudsat at der er en index.ts-fil, som (re)eksporterer alle de interessante dele af framework, opret en package.json-fil med en main og typings-post, der henviser til henholdsvis den genererede js og den genererede deklaration, dvs.

{
   "name": "framework",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   ...
 }

Forpligt dette modul til et git-repository, for eksempel bitbucket på: "https://[email /myUser/framework.git"

dep-a

i package.json opret en afhængighed til framework

{
    "dependencies": {
        "framework":     "https://[email /myUser/framework.git"
    },
}

Det er det.

import * from 'framework'

vil trække afhængigheden med typningerne, automatisk

Det er åbenlyst muligt at gøre med dep-a, hvad der blev gjort med framework, dvs. generere deklarationerne, opdatere package.json og bruge dep-a som et modul med indlejrede typinger i main

bemærk: en fil-URL fungerer i package.json/dependencies, hvis du ikke ønsker at gå via et eksternt git-repo

Svar #2

Hvad der ankom i TypeScript 1.6 er typings egenskaben i package.json modulet. Du kan tjekke det relevante issue på GitHub.

Så antager vi, at du vil oprette separate moduler (dep-a, framework). Du kan gøre følgende:

main.ts                 // (1)
package.json            // (2)
node_modules/
  dep_a/                
    index.js            // (3)
    index.d.ts          // (4)
    package.json        // (5)
    node_modules/
      framework/ 
        index.js        // (6)
        index.d.ts      // (7)
        package.json    // (8)

Så lad os se, hvad du har i dine filer :

//(1) main.ts
import * as depA from "depA";

console.log(depA({ a : true, b : 2 }) === true) // true;

//(2) package.json
{
  name: "main",
  dependencies: {
    "dep_a" : "0.0.1"
  }
  ...
}

For depA

//(3) dep_a/index.js
module.exports = function a(options) { return true; };

//(4) dep_a/index.d.ts;

import * as framework from "framework";

export interface IDepA extends framework.IFramework {
   a : boolean
}

export default function a(options: IDepA) : boolean; 

//(5) dep_a/package.json
{
  name: "dep_a",
  dependencies: {
    "framework" : "0.0.1"
  },
  ...
  typings : "index.d.ts" // < Magic happens here
}

For framework

//(6) dep_a/node_modules/framework/index.js
module.exports = true // we need index.js here, but we will only use definition file

//(7) dep_a/node_modules/framework/index.d.ts;

export interface IFramework {
   b : number;
}

//(8) dep_a/node_modules/framework/package.json
{
  name: "framework"
  ...
  typings : "index.d.ts"
}

Hvad jeg ikke inkluderer i dette svar (for klarhedens skyld) er en anden kompilationsfase, så du kunne faktisk skrive modulerne (dep_a, framework) med TypeScript og derefter kompilere dem til index.js, før du bruger dem.

Relaterede artikler