feat: #733 - Soft rename addExistingSourceFile(s)(IfExists)

packages/ts-morph/src/Project.ts

@@ -229,9 +229,19 @@ export class Project {
      * Adds source files based on file globs.
      * @param fileGlobs - File glob or globs to add files based on.
      * @returns The matched source files.
+     * @deprecated Use `addSourceFilesAtPaths`.
      */
     addExistingSourceFiles(fileGlobs: string | ReadonlyArray<string>): SourceFile[] {
-        return this._context.directoryCoordinator.addExistingSourceFiles(fileGlobs, { markInProject: true });
+        return this.addSourceFilesAtPaths(fileGlobs);
+    }
+
+    /**
+     * Adds source files based on file globs.
+     * @param fileGlobs - File glob or globs to add files based on.
+     * @returns The matched source files.
+     */
+    addSourceFilesAtPaths(fileGlobs: string | ReadonlyArray<string>): SourceFile[] {
+        return this._context.directoryCoordinator.addSourceFilesAtPaths(fileGlobs, { markInProject: true });
     }
 
     /**
@@ -240,9 +250,21 @@ export class Project {
      * Will return the source file if it was already added.
      * @param filePath - File path to get the file from.
      * @skipOrThrowCheck
+     * @deprecated Use `addSourceFileAtPathIfExists`.
      */
     addExistingSourceFileIfExists(filePath: string): SourceFile | undefined {
-        return this._context.directoryCoordinator.addExistingSourceFileIfExists(filePath, { markInProject: true });
+        return this.addSourceFileAtPathIfExists(filePath);
+    }
+
+    /**
+     * Adds a source file from a file path if it exists or returns undefined.
+     *
+     * Will return the source file if it was already added.
+     * @param filePath - File path to get the file from.
+     * @skipOrThrowCheck
+     */
+    addSourceFileAtPathIfExists(filePath: string): SourceFile | undefined {
+        return this._context.directoryCoordinator.addSourceFileAtPathIfExists(filePath, { markInProject: true });
     }
 
     /**
@@ -251,9 +273,21 @@ export class Project {
      * Will return the source file if it was already added.
      * @param filePath - File path to get the file from.
      * @throws FileNotFoundError when the file is not found.
+     * @deprecated Use `addSourceFileAtPath`.
      */
     addExistingSourceFile(filePath: string): SourceFile {
-        return this._context.directoryCoordinator.addExistingSourceFile(filePath, { markInProject: true });
+        return this.addSourceFileAtPath(filePath);
+    }
+
+    /**
+     * Adds an existing source file from a file path or throws if it doesn't exist.
+     *
+     * Will return the source file if it was already added.
+     * @param filePath - File path to get the file from.
+     * @throws FileNotFoundError when the file is not found.
+     */
+    addSourceFileAtPath(filePath: string): SourceFile {
+        return this._context.directoryCoordinator.addSourceFileAtPath(filePath, { markInProject: true });
     }
 
     /**
@@ -273,7 +307,7 @@ export class Project {
     private _addSourceFilesForTsConfigResolver(tsConfigResolver: TsConfigResolver, compilerOptions: CompilerOptions) {
         const paths = tsConfigResolver.getPaths(compilerOptions);
 
-        const addedSourceFiles = paths.filePaths.map(p => this.addExistingSourceFile(p));
+        const addedSourceFiles = paths.filePaths.map(p => this.addSourceFileAtPath(p));
         for (const dirPath of paths.directoryPaths)
             this.addExistingDirectoryIfExists(dirPath);
         return addedSourceFiles;

packages/ts-morph/src/fileSystem/Directory.ts

@@ -240,8 +240,18 @@ export class Directory {
      * Add source files based on file globs.
      * @param fileGlobs - File glob or globs to add files based on.
      * @returns The matched source files.
+     * @deprecated Use `addSourceFilesAtPaths`.
      */
     addExistingSourceFiles(fileGlobs: string | ReadonlyArray<string>): SourceFile[] {
+        return this.addSourceFilesAtPaths(fileGlobs);
+    }
+
+    /**
+     * Add source files based on file globs.
+     * @param fileGlobs - File glob or globs to add files based on.
+     * @returns The matched source files.
+     */
+    addSourceFilesAtPaths(fileGlobs: string | ReadonlyArray<string>): SourceFile[] {
         fileGlobs = typeof fileGlobs === "string" ? [fileGlobs] : fileGlobs;
         fileGlobs = fileGlobs.map(g => {
             if (FileUtils.pathIsAbsolute(g))
@@ -250,7 +260,7 @@ export class Directory {
             return FileUtils.pathJoin(this.getPath(), g);
         });
 
-        return this._context.directoryCoordinator.addExistingSourceFiles(fileGlobs, { markInProject: this._isInProject() });
+        return this._context.directoryCoordinator.addSourceFilesAtPaths(fileGlobs, { markInProject: this._isInProject() });
     }
 
     /**
@@ -317,10 +327,22 @@ export class Directory {
      * Will return the source file if it was already added.
      * @param relativeFilePath - Relative file path to add.
      * @skipOrThrowCheck
+     * @deprecated Use `addSourceFileAtPathIfExists`.
      */
     addExistingSourceFileIfExists(relativeFilePath: string): SourceFile | undefined {
+        return this.addSourceFileAtPathIfExists(relativeFilePath);
+    }
+
+    /**
+     * Adds an existing source file, relative to this directory, or returns undefined.
+     *
+     * Will return the source file if it was already added.
+     * @param relativeFilePath - Relative file path to add.
+     * @skipOrThrowCheck
+     */
+    addSourceFileAtPathIfExists(relativeFilePath: string): SourceFile | undefined {
         const filePath = this._context.fileSystemWrapper.getStandardizedAbsolutePath(relativeFilePath, this.getPath());
-        return this._context.directoryCoordinator.addExistingSourceFileIfExists(filePath, { markInProject: this._isInProject() });
+        return this._context.directoryCoordinator.addSourceFileAtPathIfExists(filePath, { markInProject: this._isInProject() });
     }
 
     /**
@@ -329,10 +351,22 @@ export class Directory {
      * Will return the source file if it was already added.
      * @param relativeFilePath - Relative file path to add.
      * @throws FileNotFoundError when the file doesn't exist.
+     * @deprecated Use `addSourceFileAtPath`.
      */
     addExistingSourceFile(relativeFilePath: string): SourceFile {
+        return this.addSourceFileAtPath(relativeFilePath);
+    }
+
+    /**
+     * Adds an existing source file, relative to this directory, or throws if it doesn't exist.
+     *
+     * Will return the source file if it was already added.
+     * @param relativeFilePath - Relative file path to add.
+     * @throws FileNotFoundError when the file doesn't exist.
+     */
+    addSourceFileAtPath(relativeFilePath: string): SourceFile {
         const filePath = this._context.fileSystemWrapper.getStandardizedAbsolutePath(relativeFilePath, this.getPath());
-        return this._context.directoryCoordinator.addExistingSourceFile(filePath, { markInProject: this._isInProject() });
+        return this._context.directoryCoordinator.addSourceFileAtPath(filePath, { markInProject: this._isInProject() });
     }
 
     /**

packages/ts-morph/src/fileSystem/DirectoryCoordinator.ts

@@ -36,29 +36,29 @@ export class DirectoryCoordinator {
         return this.compilerFactory.createDirectoryOrAddIfExists(dirPath, options);
     }
 
-    addExistingSourceFileIfExists(filePath: string, options: { markInProject: boolean; }): SourceFile | undefined {
+    addSourceFileAtPathIfExists(filePath: string, options: { markInProject: boolean; }): SourceFile | undefined {
         return this.compilerFactory.addOrGetSourceFileFromFilePath(filePath, {
             markInProject: options.markInProject,
             scriptKind: undefined
         });
     }
 
-    addExistingSourceFile(filePath: string, options: { markInProject: boolean; }): SourceFile {
-        const sourceFile = this.addExistingSourceFileIfExists(filePath, options);
+    addSourceFileAtPath(filePath: string, options: { markInProject: boolean; }): SourceFile {
+        const sourceFile = this.addSourceFileAtPathIfExists(filePath, options);
         if (sourceFile == null)
             throw new errors.FileNotFoundError(this.fileSystemWrapper.getStandardizedAbsolutePath(filePath));
         return sourceFile;
     }
 
-    addExistingSourceFiles(fileGlobs: string | ReadonlyArray<string>, options: { markInProject: boolean; }): SourceFile[] {
+    addSourceFilesAtPaths(fileGlobs: string | ReadonlyArray<string>, options: { markInProject: boolean; }): SourceFile[] {
         if (typeof fileGlobs === "string")
             fileGlobs = [fileGlobs];
 
         const sourceFiles: SourceFile[] = [];
         const globbedDirectories = FileUtils.getParentMostPaths(fileGlobs.filter(g => !FileUtils.isNegatedGlob(g)).map(g => FileUtils.getGlobDir(g)));
 
         for (const filePath of this.fileSystemWrapper.glob(fileGlobs)) {
-            const sourceFile = this.addExistingSourceFileIfExists(filePath, options);
+            const sourceFile = this.addSourceFileAtPathIfExists(filePath, options);
             if (sourceFile != null)
                 sourceFiles.push(sourceFile);
         }

packages/ts-morph/src/tests/compiler/tools/results/memoryEmitResultTests.ts

@@ -7,7 +7,7 @@ describe(nameof(MemoryEmitResult), () => {
         const project = new Project({ compilerOptions, useVirtualFileSystem: true });
         const fileSystem = project.getFileSystem();
         fileSystem.writeFileSync("file1.ts", "\uFEFFconst num1 = 1;"); // has BOM
-        project.addExistingSourceFile("file1.ts");
+        project.addSourceFileAtPath("file1.ts");
         project.createSourceFile("file2.ts", "const num2 = 2;");
         return { project, fileSystem };
     }

packages/ts-morph/src/tests/fileSystem/directoryTests.ts

@@ -361,66 +361,66 @@ describe(nameof(Directory), () => {
         });
     });
 
-    describe(nameof<Directory>(d => d.addExistingSourceFileIfExists), () => {
+    describe(nameof<Directory>(d => d.addSourceFileAtPathIfExists), () => {
         it("should return undefined if adding a source file at a non-existent path", () => {
             const fileSystem = getFileSystemHostWithFiles([]);
             const project = new Project({ fileSystem });
             const directory = project.createDirectory("dir");
-            expect(directory.addExistingSourceFileIfExists("non-existent-file.ts")).to.be.undefined;
+            expect(directory.addSourceFileAtPathIfExists("non-existent-file.ts")).to.be.undefined;
         });
 
         it("should add a source file that exists", () => {
             const fileSystem = getFileSystemHostWithFiles([{ filePath: "dir/file.ts", text: "" }], ["dir"]);
             const project = new Project({ fileSystem });
             const directory = project.addExistingDirectory("dir");
-            const sourceFile = directory.addExistingSourceFileIfExists("file.ts");
+            const sourceFile = directory.addSourceFileAtPathIfExists("file.ts");
             expect(sourceFile).to.not.be.undefined;
             expect(sourceFile!.getLanguageVersion()).to.equal(ScriptTarget.Latest);
         });
     });
 
-    describe(nameof<Directory>(d => d.addExistingSourceFile), () => {
+    describe(nameof<Directory>(d => d.addSourceFileAtPath), () => {
         it("should throw an exception if adding a source file at a non-existent path", () => {
             const fileSystem = getFileSystemHostWithFiles([]);
             const project = new Project({ fileSystem });
             const directory = project.createDirectory("dir");
             expect(() => {
-                directory.addExistingSourceFile("non-existent-file.ts");
+                directory.addSourceFileAtPath("non-existent-file.ts");
             }).to.throw(errors.FileNotFoundError, `File not found: /dir/non-existent-file.ts`);
         });
 
         it("should add a source file that exists", () => {
             const fileSystem = getFileSystemHostWithFiles([{ filePath: "dir/file.ts", text: "" }], ["dir"]);
             const project = new Project({ fileSystem });
             const directory = project.addExistingDirectory("dir");
-            const sourceFile = directory.addExistingSourceFile("file.ts");
+            const sourceFile = directory.addSourceFileAtPath("file.ts");
             expect(sourceFile).to.not.be.undefined;
             expect(sourceFile.getLanguageVersion()).to.equal(ScriptTarget.Latest);
         });
     });
 
-    describe(nameof<Directory>(d => d.addExistingSourceFiles), () => {
+    describe(nameof<Directory>(d => d.addSourceFilesAtPaths), () => {
         const fileSystem = getFileSystemHostWithFiles([{ filePath: "otherDir/file.ts", text: "" }, { filePath: "dir/dir1/dir1/file.ts", text: "" }],
             ["dir", "dir/dir1", "dir/dir2", "dir/dir1/dir1", "otherDir"]);
 
         it("should add source files by a relative file glob", () => {
             const project = new Project({ fileSystem });
             const directory = project.addExistingDirectory("dir");
-            const sourceFiles = directory.addExistingSourceFiles("**/*.ts");
+            const sourceFiles = directory.addSourceFilesAtPaths("**/*.ts");
             expect(sourceFiles.map(s => s.getFilePath())).to.deep.equal(["/dir/dir1/dir1/file.ts"]);
         });
 
         it("should add source files by multiple file globs", () => {
             const project = new Project({ fileSystem });
             const directory = project.addExistingDirectory("dir");
-            const sourceFiles = directory.addExistingSourceFiles(["**/*.ts", "../**/*.ts"]);
+            const sourceFiles = directory.addSourceFilesAtPaths(["**/*.ts", "../**/*.ts"]);
             expect(sourceFiles.map(s => s.getFilePath())).to.deep.equal(["/dir/dir1/dir1/file.ts", "/otherDir/file.ts"]);
         });
 
         it("should add source files by an absolute file glob", () => {
             const project = new Project({ fileSystem });
             const directory = project.addExistingDirectory("dir");
-            const sourceFiles = directory.addExistingSourceFiles("/otherDir/**/*.ts");
+            const sourceFiles = directory.addSourceFilesAtPaths("/otherDir/**/*.ts");
             expect(sourceFiles.map(s => s.getFilePath())).to.deep.equal(["/otherDir/file.ts"]);
         });
     });
@@ -1440,7 +1440,7 @@ describe(nameof(Directory), () => {
                 const project = new Project({ fileSystem });
                 const directory = project.addExistingDirectory("dir");
                 const childDir = directory.createDirectory("childDir");
-                const sourceFile = directory.addExistingSourceFile("file.ts");
+                const sourceFile = directory.addSourceFileAtPath("file.ts");
                 const otherSourceFile = project.createSourceFile("otherFile.ts");
 
                 deleteImmediately(directory, () => {

packages/ts-morph/src/tests/issues/413tests.ts

@@ -12,7 +12,7 @@ describe("tests for issue #413", () => {
         fs.writeFileSync("/dir2/foo.ts", "");
         fs.writeFileSync("/dir2/bar.ts", "");
 
-        const sourceFiles = project.addExistingSourceFiles(["*.ts", "dir/*.ts"]);
+        const sourceFiles = project.addSourceFilesAtPaths(["*.ts", "dir/*.ts"]);
         expect(sourceFiles.length).to.equal(3); // won't get in dir2 directory
     });
 });