Allow multiple ambient declarations for same module

.gitignore

@@ -13,6 +13,7 @@
 /test/build
 !/test/src/typings/*.d.ts
 /test/src/**/*.d.ts
+!/test/src/ambient/*.d.ts
 /test/src/**/*.js
 /test/src/**/*.js.map
 

Gruntfile.js

@@ -67,6 +67,10 @@ module.exports = function (grunt) {
 			testConflicts: {
 				src: ['test/src/conflicts/dirname/index.ts'],
 				outDir: 'test/build/conflicts/dirname'
+			},
+			testAmbient: {
+				src: ['test/src/ambient/index.ts'],
+				outDir: 'test/build/ambient'
 			}
 		},
 		mochaTest: {
@@ -92,6 +96,7 @@ module.exports = function (grunt) {
 		'ts:testEs6',
 		'ts:testCommonJs',
 		'ts:testConflicts',
+		'ts:testAmbient',
 		'run'
 	]);
 

lib/index.ts

@@ -183,7 +183,7 @@ export function bundle(options: Options): BundleResult {
             mainFileContent += generatedLine + "\n";
         });
         mainFile = path.resolve(baseDir, "dts-bundle.tmp." + exportName + ".d.ts");
-        fs.writeFileSync(mainFile, mainFileContent, 'utf8');
+        fs.writeFileSync(mainFile, mainFileContent, { encoding: 'utf8' });
     }
 
     trace('\n### find typings ###');
@@ -231,12 +231,11 @@ export function bundle(options: Options): BundleResult {
     // map all exports to their file
     trace('\n### map exports ###');
 
-    let exportMap = Object.create(null);
+    let exportMap = Object.create(null); // values are arrays of parsed files
     Object.keys(fileMap).forEach(file => {
         let parse = fileMap[file];
         parse.exports.forEach(name => {
-            assert(!(name in exportMap), 'already got export for: ' + name);
-            exportMap[name] = parse;
+            (exportMap[name] || (exportMap[name] = [])).push(parse);
             trace('- %s -> %s', name, parse.file);
         });
     });
@@ -266,20 +265,32 @@ export function bundle(options: Options): BundleResult {
             usedTypings.push(parse);
 
             parse.externalImports.forEach(name => {
-                let p = exportMap[name];
+                let parses = exportMap[name];
+
                 if (!externals) {
                     trace(' - exclude external %s', name);
-                    pushUnique(externalDependencies, !p ? name : p.file);
-                    return;
-                }
-                if (isExclude(path.relative(baseDir, p.file), true)) {
-                    trace(' - exclude external filter %s', name);
-                    pushUnique(excludedTypings, p.file);
-                    return;
+
+                    if (parses) {
+                        for (let p of parses) {
+                            pushUnique(externalDependencies, p.file);
+                        }
+                    } else {
+                        pushUnique(externalDependencies, name);
+                    }
+                } else {
+                    if (parses) {
+                        for (let p of parses) {
+                            if (isExclude(path.relative(baseDir, p.file), true)) {
+                                trace(' - exclude external filter %s', name);
+                                pushUnique(excludedTypings, p.file);
+                            } else {
+                                trace(' - include external %s', name);
+                                assert(p, name);
+                                queue.push(p);
+                            }
+                        }
+                    }
                 }
-                trace(' - include external %s', name);
-                assert(p, name);
-                queue.push(p);
             });
             parse.relativeImports.forEach(file => {
                 let p = fileMap[file];
@@ -424,7 +435,7 @@ export function bundle(options: Options): BundleResult {
             }
         }
 
-        fs.writeFileSync(outFile, content, 'utf8');
+        fs.writeFileSync(outFile, content, { encoding: 'utf8' });
         bundleResult.emitted = true;
     } else {
         warning(" XXX Not emit due to exist files not found.")
@@ -587,7 +598,7 @@ export function bundle(options: Options): BundleResult {
         if (fs.lstatSync(file).isDirectory()) { // if file is a directory then lets assume commonjs convention of an index file in the given folder
             file = path.join(file, 'index.d.ts');
         }
-        const code = fs.readFileSync(file, 'utf8').replace(bomOptExp, '').replace(/\s*$/, '');
+        const code = fs.readFileSync(file, { encoding: 'utf8' }).replace(bomOptExp, '').replace(/\s*$/, '');
         res.indent = detectIndent(code) || indent;
 
         // buffer multi-line comments, handle JSDoc
@@ -749,6 +760,11 @@ export function bundle(options: Options): BundleResult {
 
                 trace(' - declare %s', moduleName);
                 pushUnique(res.exports, moduleName);
+
+                // for internal typings, can't have nested declares w/ modules
+                if (inSourceTypings(file)) {
+                    line = line.replace('declare module', 'module');
+                }
                 let modLine: ModLine = {
                     original: line
                 };

test/expected/ambient/foo-mx.d.ts

@@ -0,0 +1,31 @@
+// Dependencies for this module:
+//   ambient1.d.ts
+//   ambient2.d.ts
+//   ../../src/ambient/mymodule.d.ts
+
+declare module 'foo-mx' {
+    export { MyInterface } from 'mymodule';
+    export { Sup1 } from 'foo-mx/ambient1';
+    export { Sup2 } from 'foo-mx/ambient2';
+}
+
+declare module 'foo-mx/ambient1' {
+    module 'mymodule' {
+        interface MyInterface {
+            prop1: string;
+        }
+    }
+    export interface Sup1 {
+    }
+}
+
+declare module 'foo-mx/ambient2' {
+    module 'mymodule' {
+        interface MyInterface {
+            prop2: string;
+        }
+    }
+    export interface Sup2 {
+    }
+}
+

test/src/ambient/ambient1.ts

@@ -0,0 +1,10 @@
+
+/// <reference path="./mymodule.d.ts" />
+
+declare module 'mymodule' {
+    interface MyInterface {
+        prop1: string
+    }
+}
+
+export interface Sup1 {}

test/src/ambient/ambient2.ts

@@ -0,0 +1,10 @@
+
+/// <reference path="./mymodule.d.ts" />
+
+declare module 'mymodule' {
+    interface MyInterface {
+        prop2: string
+    }
+}
+
+export interface Sup2 {}

test/src/ambient/index.ts

@@ -0,0 +1,3 @@
+export { MyInterface } from 'mymodule';
+export { Sup1 } from './ambient1';
+export { Sup2 } from './ambient2';

test/src/ambient/mymodule.d.ts

@@ -0,0 +1,6 @@
+
+declare module 'mymodule' {
+    export interface MyInterface {
+        prop0: string
+    }
+}

test/test.js

@@ -384,6 +384,56 @@ describe('dts bundle', function () {
 		assert.strictEqual(getFile(actualFile), getFile(expectedFile));
 	});
 
+	(function testit(name, assertion, run) {
+		var buildDir = path.resolve(__dirname, 'build', 'ambient');
+		var call = function (done) {
+			var testDir = path.join(tmpDir, name);
+			var expDir = path.join(expectDir, name);
+
+			mkdirp.sync(testDir);
+
+			ncp.ncp(buildDir, testDir, function (err) {
+				if (err) {
+					done(err);
+					return;
+				}
+				assertion(testDir, expDir);
+				done();
+			});
+		};
+
+		var label = 'bundle ' + name;
+
+		if (run === 'skip') {
+			it.skip(label, call);
+		}
+		else if (run === 'only') {
+			it.only(label, call);
+		}
+		else {
+			it(label, call);
+		}
+	})('ambient', function (actDir, expDir) {
+		var result = dts.bundle({
+			name: 'foo-mx',
+			main: path.join(actDir, 'index.d.ts'),
+			newline: '\n',
+            verbose: true,
+            headerPath: "none"
+		});
+		var name = 'foo-mx.d.ts';
+		var actualFile = path.join(actDir, name);
+        assert.isTrue(result.emitted, "not emit " + actualFile);
+		var expectedFile = path.join(expDir, name);
+		assertFiles(actDir, [
+			name,
+			'index.d.ts',
+			'ambient1.d.ts',
+			'ambient2.d.ts',
+		]);
+		assert.strictEqual(getFile(actualFile), getFile(expectedFile));
+	});
+
 	(function testit(name, assertion, run) {
 		var buildDir = path.resolve(__dirname, 'build', 'es6');
 		var call = function (done) {