Ничего плохого в ответе Райана, но для людей, которые пришли сюда, чтобы узнать, как поддерживать структуру одного класса для каждого файла при правильном использовании пространств имен ES6, обратитесь к этому полезному ресурсу от Microsoft.

Единственное, что неясно для меня после прочтения документа: как импортировать весь (объединенный) модуль с одним import.

Отредактируйте " Крутить", чтобы обновить этот ответ. Несколько подходов к namespacing появляются в TS.

Все классы модулей в одном файле.

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

Импорт файлов в пространство имен и переназначение

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

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

баррели

// ./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();

Окончательное рассмотрение. Вы можете пронумеровать каждый файл

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

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

Но поскольку один из них импортирует два класса из одного и того же пространства имен, TS будет жаловаться на дубликат идентификатора. Единственное решение, как это время, - это затем псевдоним пространства имен.

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

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

Это наложение абсолютно отвратительно, поэтому не делайте этого. Тебе лучше приступить к вышеуказанному подходу. Лично я предпочитаю "бочку".

Попробуйте организовать по папке:

baseTypes.ts

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

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

dog.ts

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

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

tree.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)

Идея состоит в том, что самим вашим модулем не должно быть никакого представления/они знают, что они участвуют в пространстве имен, но это предоставляет ваш API потребителю компактным, разумным способом, который не зависит от того, какой тип модульной системы вы используете для проект.

Несколько вопросов/комментариев, которые я видел по этому вопросу, звучат для меня так, как будто человек использует Namespace, где они означают "псевдоним модуля". Как упоминал Райан Кавано в одном из своих комментариев, у вас может быть модуль "Wrapper", который реэкспортирует несколько модулей.

Если вы действительно хотите импортировать все из одного и того же имени модуля/псевдонима, объедините модуль-оболочку с отображением путей в tsconfig.json.

Пример:

./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'

Примечание: разрешение модуля в выходных файлах .js необходимо будет каким-то образом обработать, например, с помощью https://github.com/tleunen/babel-plugin-module-resolver

Пример .babelrc для обработки разрешения псевдонима:

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

OP Я с тобой человек. опять же, нет ничего плохого в этом ответе с более чем 300 голосами, но мое мнение таково:

• Что не так, если поместить классы в свои уютные собственные собственные файлы? Я имею в виду, что это будет выглядеть намного лучше? (или кто-то, как 1000 строк для всех моделей)

• тогда, если первая будет достигнута, нам нужно импортировать импорт импорта... импортировать только в каждый из файлов модели, например man, srsly, файл модели, файл .d.ts, почему там так много? это должно быть просто, аккуратно и так. Почему мне нужен импорт? Зачем? С# получили пространства имен по какой-либо причине.

• И к тому времени вы буквально используете "filenames.ts" в качестве идентификаторов. Как идентификаторы... Приходите на его 2017 сейчас, и мы все еще это делаем? Има возвращается на Марс и спит еще 1000 лет.

К сожалению, мой ответ: nop, вы не можете использовать функциональность "пространства имен", если вы не используете все эти импорты или используете эти имена файлов в качестве идентификаторов (что, на мой взгляд, действительно глупо). Другой вариант: поместите все эти зависимости в поле с именем filenameasidentifier.ts и используйте

export namespace(or module) boxInBox {} .

оберните их, чтобы они не пытались получить доступ к другим классам с одинаковым именем, когда они просто пытаются получить ссылку из класса, сидеть прямо поверх них.

Небольшое подчинение Альбинофанти:

base.ts

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

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

dog.ts

import * as b from './base';

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

things.ts

import { Dog } from './dog'

namespace things {
  export const dog = Dog;
}

export = things;

main.ts

import * as things from './things';

console.log(things.dog);

dog.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;
        }
    }
}

tree.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 {
    }
}

Necromancing.

Если я правильно понимаю, вы спрашиваете, как иметь все ваши классы в одном отдельном файле, сохраняя для них одно пространство имен.

Так как никто, кажется, не имеет хорошего решения - вот идея простого решения, в которое даже не входит typescript: это решение называется Gulp.

Просто поместите все свои классы, которые должны находиться в одном пространстве имен в одну и ту же папку (полезно для кодовой организации). Затем добавьте gulp -task, который объединяет все файлы в этом каталоге в один файл (gulp -concat). Затем добавьте пространство имен с тем же именем, что и верхний каталог, затем добавьте конкатенированные файлы, затем добавьте закрытие и сохраните в один файл.

Готово.

Затем добавьте gulp -task, которая следит за изменениями (и добавлениями/удалениями) в том же каталоге. При изменении/добавлении запускайте функцию concat.

Теперь у вас есть все классы в одном файле и один файл, содержащий все классы в одном пространстве имен.

Пример кода - по строкам:

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']);
});

Здесь 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/'));
});

Наконец, настройте наблюдателя на загрузку решения, и все готово.