File di definizione generati (.d.ts) per dattiloscritto che non funziona con types package.json

Question

Ho creato un file di definizione (d.ts) dal mio progetto dattiloscritto usando l'argomento --declaration dal compilatore tsc.

Ma questo file di definizione generato a quanto pare non funziona quando si tenta di pubblicare il pacchetto con la proprietà tipizzazioni al NPM package.json. Ho creato un altro progetto per testarlo.

Si lamenta con il messaggio: "Esportato pacchetto esterno di file tipizzazioni di file' ... d.tS' non è un modulo Si prega di contattare il pacchetto autore di aggiornare la definizione del pacchetto.".

Questo sono i miei file di origine:

MyInterface.ts

export interface MyInterface 
{ 
    MyProperty: string; 
} 

MyClass.ts

import {MyInterface} from './MyInterface'; 

export class MyClass implements MyInterface 
{ 
    get MyProperty(): string 
    { 
     return "MyString"; 
    } 
} 

MyInheritedClass.ts

import {MyClass} from './MyClass'; 

export class MyInheritedClass extends MyClass 
{ 
    public MyMethod(): number 
    { 
     return 1; 
    } 
} 

Il comando TSC è questo:

tsc MyClass.ts MyInterface.ts MyInheritedClass.ts --declaration -t es5 -outFile "mydefinition.js" --module "system" 

Questa è la definizione generato:

mydefinition.d.ts

declare module "MyInterface" { 
    export interface MyInterface { 
     MyProperty: string; 
    } 
} 
declare module "MyClass" { 
    import { MyInterface } from "MyInterface"; 
    export class MyClass implements MyInterface { 
     MyProperty: string; 
    } 
} 
declare module "MyInheritedClass" { 
    import { MyClass } from "MyClass"; 
    export class MyInheritedClass extends MyClass { 
     MyMethod(): number; 
    } 
} 

c'è un'altra cosa che devo da fare o la definizione generata presumibilmente non funziona nelle tipizzazioni package.json ??

Aggiornamento per maggiori dettagli:

Lo scenario è che ho 2 progetti:

• Il primo progetto è dove ho generare la libreria dove ho pubblicherò al NPM, e il pacchetto .json è dove metto la proprietà typings che collega al file mydefinition.d.ts generato dal comando tsc -d.

• Il secondo progetto creato per testare il primo aggiungendo il pacchetto (con le digitazioni) generato.

un legame con il 2 progetti e un altro link per lo scenario:

https://github.com/jvitor83/typings-packagejson

Credo che il problema è con la "I tuoi file di definizione dovrebbero essere scritti come moduli esterni" alla prima collegamento. Ma voglio sapere se c'è un modo per ottenere quelle definizioni generate per mettere la proprietà typings di package.json.

per riprodurre il problema:

• Clone questa repo: https://github.com/jvitor83/test-typings-packagejson

• Do 'NPM install', aperto con VSCode e passare al file 'src/test.ts'.

Answer 1

La soluzione era:

1 - aggiungere un singolo file 'index.ts' che esporta tutti i file altrui.

export * from "./MyInterface" 
export * from "./MyClass" 
export * from "./MyInheritedClass" 

2 - aggiungere al processo di costruzione di due di compilazione/transpilation dei file (uno per le dichiarazioni e un altro per le singole js file [con la proprietà in TSC compilatore])

let tsConfigDeclaration = gulp_typescript({module: 'system', target: 'es5', declaration: true, removeComments: true }); 
let tsConfigOneFile = gulp_typescript({module: 'system', target: 'es5', declaration: true, removeComments: true, out: 'typings-packagejson.js'}); 

Maggiori informazioni su costruire processo: file di https://github.com/jvitor83/typings-packagejson/blob/master/gulpfile.js

e l'indice: https://github.com/jvitor83/typings-packagejson/blob/master/app/src/typings-packagejson.ts

Answer 2

Quando si verifica questo errore?

Ho utilizzato il file d.ts generato in un altro progetto e funziona correttamente.

/// <reference path="mydefinition.d.ts" /> 

    import { MyInterface } from "MyInterface"; 
    import { MyClass } from "MyClass"; 
    import { MyInheritedClass } from "MyInheritedClass"; 

    let x: MyInterface = { MyProperty: "hello!!" }; 
    let y: MyClass = new MyClass(); 
    let z: MyInheritedClass = new MyInheritedClass(); 

E su compilarlo sta generando il file JS,

/// <reference path="mydefinition.d.ts" /> 
"use strict"; 
var MyClass_1 = require("MyClass"); 
var MyInheritedClass_1 = require("MyInheritedClass"); 
var x = { MyProperty: "hello!!" }; 
var y = new MyClass_1.MyClass(); 
var z = new MyInheritedClass_1.MyInheritedClass(); 

State ottenendo questo errore quando si utilizza questo in qualche file HTML? Hai incluso il file mydefinition.js nell'HTML?

Aggiornamento

in base alle tue maggiori dettagli, ecco la soluzione che può proporre, aggiungere un altro file di nome index.ts ed esportare tutti i moduli da lì,

index.ts

export * from "./MyInterface" 
    export * from "./MyClass" 
    export * from "./MyInheritedClass" 

Aggiungere un file tsconfig.json per una facile costruzione,

tsconfig.json

{ 
    "version": "1.0.0", 
    "compilerOptions": { 
     "target": "ES5", 
     "module": "commonjs", 
     "moduleResolution": "node", 
     "sourceMap": false, 
     "declaration": true, 
     "outDir": "lib/" 
    }  
    } 

Nota ho fatto un modulo commonjs (non so se funziona per il vostro bisogno), generare costruire utilizzando il comando TSC. Genera file come sotto nota ha aggiunto file js per tutti i file ts e d.ts è anche per tutti i moduli, ma dato che abbiamo esportato tutti i moduli da un singolo file sarà più facile da usare nel file package.json per il modulo npm .

Quindi aggiungere package.json nel modulo NPM si desidera pubblicare come qui di seguito, consideriamo nome del modulo è foo

package.json

{ 
    "name": "foo", 
    "author": "author name", 
    "version": "1.0.0", 
    "main": "lib/index.js", 
    "typings": "lib/index.d.ts" 
    } 

Ora aggiungi la cartella foo all'interno di node_module, la struttura finale del secondo progetto sarà qualcosa di seguito,

Infine nel file test.ts importazione e l'uso,

test.ts

import { MyInterface, MyClass, MyInheritedClass } from "foo"; 

    let x: MyInterface = { MyProperty: "hello!!" }; 
    let y: MyClass = new MyClass(); 
    let z: MyInheritedClass = new MyInheritedClass(); 

Spero che questo aiuti.