Pytanie Jak napisać moduł węzła za pomocą maszynopisu?


Tak więc ogólna odpowiedź na inne pytanie (jak się masz import moduł za pomocą maszynopisu) to:

1) Utwórz plik definicji blah.d.ts.

2) Użyj:

/// <reference path="./defs/foo/foo.d.ts"/>
import foo = require("foo");

Krytycznie, potrzebujesz obie pliki foo.d.ts i foo.js gdzieś w module node_modules do załadowania; i NAZWA foo musi dokładnie mecz dla obu. Teraz...

Pytanie, na które chciałbym odpowiedzieć, brzmi: jak do ciebie pisać moduł maszynopisu, który można zaimportować w ten sposób?

Powiedzmy, że mam moduł podobny do tego:

- xq/
- xq/defs/Q.d.ts
- xq/index.ts
- xq/base.ts
- xq/thing.ts

Chcę wyeksportować moduł "xq" z klasami "Base" z base.ts i "Thing" z thing.ts.

Jeśli był to moduł węzłowy w javascript, mój index.ts wyglądałby tak:

var base = require('./base');
var thing = require('./thing');
module.exports = {
  Base: base.Base,
  Thing: thing.Thing
};

Spróbujmy użyć podobnego pliku maszynopisu:

import base = require('./base');
export module xq {
    export var base = base.Base;
}

Wywołaj:

tsc base.ts index.ts things.ts ... --sourcemap --declaration --target ES3 
                                   --module commonjs --outDir dist/xq

Co się dzieje? Dostajemy nasze base.d.ts:

export declare class Base<T> {
  ...
}

i ekscytująco nieprzydatny index.d.ts:

export declare module xq {
    var Base: any; // No type hinting! Great. :(
}

i całkowicie niepoprawny javascript, który nie importuje zdarzenia do modułu:

(function (xq) {
    xq.base = xq.base.Base;
})(exports.xq || (exports.xq = {}));
var xq = exports.xq;

Próbowałem wielu wariacji na temat i jedyne, co mogę zrobić, to:

declare var require;
var base = require('./base');
export module xq {
    export var base = base.Base;
}

... ale to oczywiście całkowicie niszczy sprawdzanie typu.

Więc.

Maszynopis jest świetny, ale rzeczy z tego modułu całkowicie są do bani.

1) Czy można to zrobić za pomocą wbudowanego generatora definicji (jestem wątpliwy)

2) Jak robisz to ręcznie? Widziałem instrukcje importowania w plikach .d.ts, które, jak sądzę, oznaczają, że ktoś się domyślił, jak to zrobić; jak oni działają? Jak zrobić maszynopis dla modułu, który ma deklarację zawierającą instrukcję importu?

(np. podejrzewam, że prawidłowym sposobem wykonania deklaracji modułu jest:

/// <reference path="base.d.ts" />
declare module "xq" {
  import base = require('./base'); 
  module xq {
    // Some how export the symbol base.Base as Base here
  }
  export = xq;
}

... ale nie mam pojęcia, jaki będzie tekst maszynopisu).


11
2018-05-19 13:26


pochodzenie




Odpowiedzi:


W przypadku JavaScript:

var base = require('./base');
var thing = require('./thing');
module.exports = {
  Base: base.Base,
  Thing: thing.Thing
};

TypeScript:

import base = require('./base');
import thing = require('./thing');
var toExport = {
  Base: base.Base,
  Thing: thing.Thing
};
export = toExport;

Albo nawet ten maszynopis:

import base = require('./base');
import thing = require('./thing');
export var Base = base.Base;
export var Thing = thing.Thin;

7
2018-05-21 00:51



lub jeśli '.base' i '.thing' moduły bezpośrednio eksportowały swoje definicje klas, możesz również to zrobić: export import Base = require('./base'); export import Thing = require('./thing'); - yortus


Maszynopis poprawił się znacznie, odkąd zadawano to pytanie. W ostatnich wersjach maszynopisu język stał się znacznie surowszym nadzbiorem JavaScript.

Właściwą metodą importowania / eksportowania modułów jest teraz nowa składnia modułu ES6:

myLib.ts

export function myFunc() {
  return 'test'
}

package.json

{
  "name": "myLib",
  "main": "myLib.js",
  "typings": "myLib.d.ts"
}

Zależności mogą następnie zaimportować moduł przy użyciu nowej składni ES6:

dependent.ts

import { myFunc } from 'myLib'

console.log(myFunc())
// => 'test'

Aby uzyskać pełny przykład modułu węzła napisanego w Maszynopisie, sprawdź ten szablon:

https://github.com/bitjson/typescript-starter/


2
2018-02-15 00:56