Avoid duplicate files are included

Gruntfile.js

@@ -67,7 +67,11 @@ module.exports = function (grunt) {
 			testConflicts: {
 				src: ['test/src/conflicts/dirname/index.ts'],
 				outDir: 'test/build/conflicts/dirname'
-			}
+			},
+			testDotSlash: {
+				src: ['test/src/dot-slash/index.ts'],
+				outDir: 'test/build/dot-slash'
+      }
 		},
 		mochaTest: {
 			options: {
@@ -92,6 +96,7 @@ module.exports = function (grunt) {
 		'ts:testEs6',
 		'ts:testCommonJs',
 		'ts:testConflicts',
+		'ts:testDotSlash',
 		'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 ###');
@@ -424,7 +424,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.")
@@ -517,7 +517,7 @@ export function bundle(options: Options): BundleResult {
     }
 
     function getModName(file: string) {
-        return path.relative(baseDir, path.dirname(file) + path.sep + path.basename(file).replace(/\.d\.ts$/, ''));
+        return path.relative(baseDir, path.dirname(file) + path.sep + path.basename(file).replace(/index\.d\.ts$|\.d\.ts$/, ''));
     }
 
     function getExpName(file: string) {
@@ -584,9 +584,6 @@ export function bundle(options: Options): BundleResult {
             res.fileExists = false;
             return res;
         }
-        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*$/, '');
         res.indent = detectIndent(code) || indent;
 
@@ -717,6 +714,9 @@ export function bundle(options: Options): BundleResult {
                     if(!fs.existsSync(full) || fs.existsSync(full + '.d.ts')) {
                         full += '.d.ts';
                     }
+                    if (fs.lstatSync(full).isDirectory()) {
+                        full = path.join(full, 'index.d.ts'); // normalize to actual file path
+                    }
                     trace(' - import relative %s (%s)', moduleName, full);
 
                     pushUnique(res.relativeImports, full);

test/expected/dot-slash/bundle.d.ts

@@ -0,0 +1,16 @@
+
+declare module 'bundle' {
+    import { SomeOtherClass } from "bundle/SomeOtherClass";
+    export interface IShouldBeThereOnlyOnce {
+        name: string;
+    }
+    export function getOther(): SomeOtherClass;
+}
+
+declare module 'bundle/SomeOtherClass' {
+    import { IShouldBeThereOnlyOnce } from "bundle/";
+    export class SomeOtherClass {
+        static saveTheWorld(once: IShouldBeThereOnlyOnce): Promise<any>;
+    }
+}
+

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

@@ -1,28 +1,28 @@
 
 declare module 'foo-mx' {
     import exp = require('foo-mx/lib/exported-sub');
-    import mod1 = require('foo-mx/index//external1');
+    import mod1 = require('foo-mx///external1');
     export import Foo = require('foo-mx/Foo');
     export function run(foo?: Foo): Foo;
     export function flep(): exp.ExternalContainer;
     export function bar(): mod1.SomeType;
 }
 
-declare module 'foo-mx/index//external1' {
+declare module 'foo-mx///external1' {
     export class SomeType {
         foo(): void;
     }
 }
 
-declare module 'foo-mx/index//external2' {
+declare module 'foo-mx///external2' {
     export class AnotherType {
         foo(): void;
     }
 }
 
 declare module 'foo-mx/lib/exported-sub' {
     import Foo = require('foo-mx/Foo');
-    import mod2 = require('foo-mx/index//external2');
+    import mod2 = require('foo-mx///external2');
     export class ExternalContainer {
         something: mod2.AnotherType;
     }

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

@@ -1,20 +1,20 @@
 
 declare module 'foo-mx' {
     import exp = require('foo-mx/lib/exported-sub');
-    import mod1 = require('foo-mx/index//external1');
+    import mod1 = require('foo-mx///external1');
     export import Foo = require('foo-mx/Foo');
     export function run(foo?: Foo): Foo;
     export function flep(): exp.ExternalContainer;
     export function bar(): mod1.SomeType;
 }
 
-declare module 'foo-mx/index//external1' {
+declare module 'foo-mx///external1' {
     export class SomeType {
         foo(): void;
     }
 }
 
-declare module 'foo-mx/index//external2' {
+declare module 'foo-mx///external2' {
     export class AnotherType {
         foo(): void;
     }

test/src/dot-slash/SomeOtherClass.ts

@@ -0,0 +1,8 @@
+import {IShouldBeThereOnlyOnce} from "./"; // The tricky part
+
+export class SomeOtherClass {
+
+  public static saveTheWorld(once: IShouldBeThereOnlyOnce): Promise<any> {
+    return null;
+  }
+}

test/src/dot-slash/index.ts

@@ -0,0 +1,13 @@
+'use strict';
+
+import {SomeOtherClass} from "./SomeOtherClass";
+
+const other: SomeOtherClass = new SomeOtherClass();
+
+export interface IShouldBeThereOnlyOnce {
+  name: string,
+}
+
+export function getOther(): SomeOtherClass {
+  return null;
+}

test/test.js

@@ -532,4 +532,54 @@ describe('dts bundle', function () {
 		]);
 		assert.strictEqual(getFile(actualFile), getFile(expectedFile));
 	});
+
+  (function testit(name, assertion, run) {
+    var buildDir = path.resolve(__dirname, 'build', name);
+    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);
+    }
+  })('dot-slash', function (actDir, expDir) {
+    var result = dts.bundle({
+      name: 'bundle',
+      main: path.join(actDir, '../dot-slash', 'index.d.ts'),
+      newline: '\n',
+      verbose: true,
+      headerPath: "none"
+    });
+    var name = 'bundle.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',
+      'SomeOtherClass.d.ts'
+    ]);
+    assert.strictEqual(getFile(actualFile), getFile(expectedFile));
+  })
+
 });