Nie ma nic złego w odpowiedzi Ryana, ale dla osób, które przyjechały tutaj, szukając sposobu utrzymania struktury jednej klasy na plik , wciąż poprawnie używającej przestrzeni nazw ES6, zapoznaj się z tym pomocnym zasobem firmy Microsoft.

Jedna rzecz, która jest dla mnie niejasna po przeczytaniu doc, to: jak zaimportować cały (scalony) moduł z pojedynczym import.

Edit / Align = "left" / Kilka podejść do przestrzeni nazw pojawia się w TS.

Wszystkie klasy modułów w jednym pliku.

export namespace Shapes {
    export class Triangle {}
    export class Square {}      
}

Importuj pliki do przestrzeni nazw i ponownie przypisuj

import { Triangle as _Triangle } from './triangle';
import { Square as _Square } from './square';

export namespace Shapes {
  export const Triangle = _Triangle;
  export const Square = _Square;
}

Beczki

// ./shapes/index.ts
export { Triangle } from './triangle';
export { Square } from './square';

// in importing file:
import * as Shapes from './shapes/index.ts';
// by node module convention, you can ignore '/index.ts':
import * as Shapes from './shapes';
let myTriangle = new Shapes.Triangle();

Ostateczne rozważenie. Możesz przestrzeń nazw KAŻDEGO pliku

// triangle.ts
export namespace Shapes {
    export class Triangle {}
}

// square.ts
export namespace Shapes {
    export class Square {}
}

Ale gdy jedna importuje dwie klasy z tej samej przestrzeni nazw, TS będzie narzekać, że istnieje duplikat identyfikatora. Jedynym rozwiązaniem Jak tym razem jest wtedy alias przestrzeni nazw.

import { Shapes } from './square';
import { Shapes as _Shapes } from './triangle';

// ugh
let myTriangle = new _Shapes.Shapes.Triangle();

Spróbuj uporządkować według folderu:

Basetypy.ts

export class Animal {
    move() { /* ... */ }
}

export class Plant {
    photosynthesize() { /* ... */ }
}

Pies.ts

import b = require('./baseTypes');

export class Dog extends b.Animal {
    woof() { }
}   

Drzewo.ts

import b = require('./baseTypes');

class Tree extends b.Plant {
}

LivingThings.ts

import dog = require('./dog')
import tree = require('./tree')

export = {
    dog: dog,
    tree: tree
}

Main.ts

import LivingThings = require('./LivingThings');
console.log(LivingThings.Tree)
console.log(LivingThings.Dog)

Chodzi o to , że Twój moduł nie powinien się przejmować / wiedzieć, że uczestniczy w przestrzeni nazw, ale to naraża twoje API na konsumenta w Kompaktowy, rozsądny sposób, który jest niezależny od typu systemu modułów, którego używasz w projekcie.

Mała impovement Albinofrenchy odpowiedź:

Baza.ts

export class Animal {
move() { /* ... */ }
}

export class Plant {
  photosynthesize() { /* ... */ }
}

Pies.ts

import * as b from './base';

export class Dog extends b.Animal {
   woof() { }
} 

Rzeczy.ts

import { Dog } from './dog'

namespace things {
  export const dog = Dog;
}

export = things;

Main.ts

import * as things from './things';

console.log(things.dog);

Jestem z Tobą. znowu też nie ma nic złego w tej odpowiedzi z głosami 300 + up, ale moja opinia jest taka:

1. Co jest złego w umieszczaniu zajęć w przytulnych, ciepłych plikach indywidualnie? To sprawi, że będzie lepiej, prawda? (lub ktoś taki jak plik 1000 linii dla wszystkich modeli)

2. Tak więc, jeśli pierwszy zostanie osiągnięty, musimy zaimportować import import... Importuj tylko do każdego z plików modelu, takich jak man, srsly, model / align = "left" / plik d. ts, dlaczego jest tam tyle * s ? powinno być proste, schludne i tyle. Po co mi import? dlaczego? C# ma przestrzenie nazw nie bez powodu.

3. Do tego czasu dosłownie używasz "nazw plików.ts " jako identyfikatory. Jako identyfikatory... Przyjdź na jego 2017 teraz i nadal to robimy? Ima wrócić na Marsa i spać przez kolejne 1000 lat.

Więc niestety, moja odpowiedź brzmi: nop, nie możesz sprawić, że "przestrzeń nazw" będzie funkcjonalna, jeśli nie używasz tych wszystkich importuje lub używa tych nazw plików jako identyfikatorów (co moim zdaniem jest naprawdę głupie). Inną opcją jest: umieść wszystkie te zależności w polu o nazwie filenameasidentifier.ts i użycie

export namespace(or module) boxInBox {} .

Owiń je tak, aby nie próbowały uzyskać dostępu do innych klas o tej samej nazwie, gdy po prostu próbują uzyskać odniesienie od klasy siedzącej tuż nad nimi.

Kilka pytań / komentarzy, które widziałem wokół tego tematu, brzmi dla mnie tak, jakby osoba używała Namespace, gdzie oznaczają "alias modułu". Jak wspomniał Ryan Cavanaugh w jednym ze swoich komentarzy, moduł "Wrapper" można ponownie wyeksportować kilka modułów.

Jeśli naprawdę chcesz zaimportować to wszystko z tej samej nazwy/aliasu modułu, połącz moduł wrappera z mapowaniem ścieżek w Twoim tsconfig.json.

Przykład:

./path/to/CompanyName.Products/Foo.ts

export class Foo {
    ...
}

./path/to/CompanyName.Products/Bar.ts

export class Bar {
    ...
}

./path/to/CompanyName.Products/index.ts

export { Foo } from './Foo';
export { Bar } from './Bar';

tsconfig.json

{
    "compilerOptions": {
        ...
        paths: {
            ...
            "CompanyName.Products": ["./path/to/CompanyName.Products/index"],
            ...
        }
        ...
    }
    ...
}

main.ts

import { Foo, Bar } from 'CompanyName.Products'

Uwaga : rozdzielczość modułu na wyjściu .Pliki js będą musiały być jakoś obsługiwane, np. za pomocą tego https://github.com/tleunen/babel-plugin-module-resolver

Przykład .babelrc do obsługi rozdzielczości aliasu:

{
    "plugins": [
        [ "module-resolver", {
            "cwd": "babelrc",
            "alias": {
                "CompanyName.Products": "./path/to/typescript/build/output/CompanyName.Products/index.js"
            }
        }],
        ... other plugins ...
    ]
}

Pies.ts

import b = require('./baseTypes');

export module Living.Things {
    // Error, can't find name 'Animal', ??
    // Solved: can find, if properly referenced; exporting modules is useless, anyhow
    export class Dog extends b.Living.Things.Animal {
        public woof(): void {
            return;
        }
    }
}

Drzewo.ts

// Error, can't use the same name twice, ??
// Solved: cannot declare let or const variable twice in same scope either: just use a different name
import b = require('./baseTypes');
import d = require('./dog');

module Living.Things {
    // Why do I have to write b.Living.Things.Plant instead of b.Plant??
    class Tree extends b.Living.Things.Plant {
    }
}

Nekromancja.
Jeśli dobrze rozumiem, pytasz, Jak mieć wszystkie swoje klasy w jednym osobnym pliku, zachowując jedną przestrzeń nazw dla nich wszystkich.

Ponieważ wydaje się, że nikt nie ma dobrego rozwiązania - oto pomysł na proste rozwiązanie, które nawet nie obejmuje maszynopisu: To rozwiązanie nazywa się Gulp .

Po prostu umieść wszystkie swoje klasy, które muszą znajdować się w jednej przestrzeni nazw w tym samym folderze (przydatne dla organizacji kodu). Następnie Dodaj zadanie, które Scala wszystkie pliki w tym katalogu w jeden plik (gulp-concat). Następnie dodaj przestrzeń nazw o tej samej nazwie co katalog górny, następnie dodaj skonkatenowane pliki, następnie dodaj nawias zamykający i zapisz do jednego pliku.
Załatwione.
Następnie dodaj gulp-task, które obserwuje zmiany (i uzupełnienia/usunięcia) w tym samym katalogu. Przy zmianie / dodaniu uruchom funkcję concat.

Teraz masz wszystkie klasy w jednym pliku i jeden plik, który zawiera wszystkie klasy w jednej przestrzeni nazw.
Przykładowy kod - wzdłuż linii:

gulp.task("js:min:all", function ()
{
    return gulp.src(["./wwwroot/app/**/*.js", "!" + "./wwwroot/app/**/*.min.js"
        , "./wwwroot/GeneratedScripts/**/*.js", "!" + "./wwwroot/GeneratedScripts/**/*.min.js"], { base: "." })
        .pipe(concat("./wwwroot/js/myscripts.min.js"))
        .pipe(uglify())
        .pipe(gulp.dest("."));
});



gulp.task('watch:js', function ()
{
    gulp.watch('js/**/*.js', ['js:min:all']);
});

Jest tu moduł gulp append-prepend: https://www.npmjs.com/package/gulp-append-prepend

var gap = require('gulp-append-prepend');

gulp.task('myawesometask', function(){
    gulp.src('index.html')
    .pipe(gap.prependFile('header.html'))
    .pipe(gap.prependText('<!-- HEADER -->'))
    .pipe(gap.appendText('<!-- FOOTER -->'))
    .pipe(gap.appendFile('footer.html'))
    .pipe(gulp.dest('www/'));
});

Na koniec ustaw obserwator na start przy ładowaniu rozwiązania i gotowe.