fcis 0.1.0

package/vendor/ts-morph/docs/manipulation/transforms.md

@@ -0,0 +1,84 @@
+---
+title: Transforms
+---
+
+## Transforms
+
+It is possible to transform the AST using the compiler API, though this is not a typical scenario.
+
+For example:
+
+```ts
+import { ts } from "ts-morph";
+
+const project = new Project();
+const sourceFile = project.createSourceFile("Example.ts", "1; 2; 3;");
+
+// this can be done starting on any node and not just the root node
+sourceFile.transform(traversal => {
+  const node = traversal.visitChildren(); // return type is `ts.Node`
+
+  if (ts.isNumericLiteral(node)) {
+    const incrementedValue = parseInt(node.text, 10) + 1;
+    return traversal.factory.createNumericLiteral(incrementedValue.toString());
+  }
+
+  return node;
+});
+
+// outputs: 2; 3; 4;
+console.log(sourceFile.getFullText());
+```
+
+Doing this is more performant, but you won't have type checking, symbols, and you'll be dealing directly with the TypeScript compiler API nodes. Additionally, all previously wrapped descendant nodes of transformed nodes will be forgotten (using them will result in an error being thrown).
+
+### Conditionally visiting children
+
+```ts
+import { ts } from "ts-morph";
+
+const project = new Project();
+const sourceFile = project.createSourceFile(
+  "Example.ts",
+  `
+class C1 {
+    myMethod() {
+        function nestedFunction() {
+        }
+    }
+}
+
+class C2 {
+    prop1: string;
+}
+
+function f1() {
+    console.log("1");
+
+    function nestedFunction() {
+    }
+}`,
+);
+
+sourceFile.transform(traversal => {
+  // this will skip visiting the children of the classes
+  if (ts.isClassDeclaration(traversal.currentNode))
+    return traversal.currentNode;
+
+  const node = traversal.visitChildren();
+  if (ts.isFunctionDeclaration(node)) {
+    return traversal.factory.updateFunctionDeclaration(
+      node,
+      [],
+      [],
+      undefined,
+      traversal.factory.createIdentifier("newName"),
+      [],
+      [],
+      undefined,
+      traversal.factory.createBlock([]),
+    );
+  }
+  return node;
+});
+```

package/vendor/ts-morph/docs/metrics/performance.json

@@ -0,0 +1,4 @@
+{
+  "1": { "name": "Renaming Performance Test", "runs": [{ "dateTime": 1555118846870, "duration": 10905, "version": "1.3.2" }] },
+  "2": { "name": "Removing Performance Test", "runs": [{ "dateTime": 1555118846870, "duration": 14834, "version": "1.3.2" }] }
+}

package/vendor/ts-morph/docs/navigation/ambient-modules.md

@@ -0,0 +1,22 @@
+---
+title: Ambient Modules
+---
+
+## Ambient Modules
+
+The ambient module symbols can be retrieved by calling:
+
+```ts
+const ambientModules = project.getAmbientModules();
+```
+
+This will return the ambient modules resolved by the compiler (ex. ambient modules in `@types` or `node_modules`).
+
+### Getting by name
+
+Get an ambient module symbol based on its name:
+
+```ts
+const jQuerySymbol = project.getAmbientModule("jquery"); // returns: Symbol | undefined
+const momentSymbol = project.getAmbientModuleOrThrow("moment"); // returns: Symbol
+```

package/vendor/ts-morph/docs/navigation/compiler-nodes.md

@@ -0,0 +1,82 @@
+---
+title: Underlying Compiler Nodes
+---
+
+## Underlying Compiler Nodes
+
+Sometimes it might be useful to get the node from the TypeScript compiler.
+
+They're accessible via the `.compilerNode` property that's found on all node objects:
+
+```ts
+const compilerNode = interfaceDeclaration.compilerNode;
+```
+
+**Warning:** When manipulating the AST via this library, the underlying TypeScript AST tree is regenerated each time. For this reason, it's important not
+to hold on to TypeScript compiler nodes between manipulations or you could end up working with out of date information.
+
+### Compiler node properties
+
+Sometimes there isn't a helper function in this library for accessing certain properties on the underlying compiler node.
+
+In these situations, you can access any underlying compiler node property by using the `.getNodeProperty(propName)` method:
+
+```ts
+const nameNode = propertyAccessExpression.getNodeProperty("name"); // returns: PropertyName
+// also works with arrays and possibly undefined properties
+const typeParameters = classDeclaration.getNodeProperty("typeParameters"); // returns: TypeParameterDeclaration[] | undefined
+```
+
+...and then please open an issue so that I can implement something I forgot to implement.
+
+## Navigating Existing Compiler Nodes
+
+Sometimes you might want to easily navigate an existing compiler node.
+
+Do that by using the `createWrappedNode` function:
+
+```ts ignore-error: 1109
+import { createWrappedNode, ClassDeclaration, ts, SyntaxKind } from "ts-morph";
+
+// some code that creates a class declaration using the ts object
+const classNode: ts.ClassDeclaration = ...;
+
+// create and use a wrapped node
+const classDec = createWrappedNode(classNode).asKindOrThrow(SyntaxKind.ClassDeclaration);
+const firstProperty = classDec.getProperties()[0];
+
+// ... do more stuff here ...
+```
+
+**Note:** This is a lightweight way to navigate a node, but there are certian functionalities which will throw an error since there is no
+language service, type checker, or program. For example, finding references will not work because that requires a language service.
+
+### Providing Type Checker
+
+If you would like to easily get the type information of the types in the provided source file, then provide a type checker:
+
+```ts ignore-error: 1109
+// given an existing node and type checker
+const classNode: ts.ClassDeclaration = ...;
+const compilerTypeChecker: ts.TypeChecker = ...;
+
+// create and use a wrapped node
+const classDec = createWrappedNode(classNode, { typeChecker: compilerTypeChecker }).asKindOrThrow(SyntaxKind.ClassDeclaration);
+console.log(classDec.getPropertyOrThrow("propName").getType().getText()); // ok, because a type checker was provided
+```
+
+### Important: Using both the TypeScript API and ts-morph
+
+It is highly recommended to always use the `ts` named export from ts-morph when
+needing to use the TypeScript Compiler API and ts-morph at the same time:
+
+```ts
+// do this
+import { ts } from "ts-morph";
+// not this
+import * as ts from "typescript";
+```
+
+They're almost identical and the `ts` named export from ts-morph should serve your needs.
+
+There's lots of reasons why this is done and it's outlined in [#333](https://github.com/dsherret/ts-morph/issues/333#issuecomment-391182952).

package/vendor/ts-morph/docs/navigation/directories.md

@@ -0,0 +1,287 @@
+---
+title: Directories
+---
+
+## Directories
+
+Based on the source files created, appropriate directory objects will be created. These objects hold source files and directories that have been added.
+
+Note that it's completely fine to ignore the concept of directories and only deal with source files. This is an advanced feature that
+only needs to be used if it will help make solving your problem easier.
+
+### Retrieving
+
+Directories can be retrieved from a source file:
+
+```ts
+const directory = sourceFile.getDirectory();
+```
+
+From other directories:
+
+```ts
+directory.getDirectory("childDir");
+directory.getDirectoryOrThrow("childDir");
+// child directories
+directory.getDirectories();
+// parent directory, if it exists
+directory.getParent();
+```
+
+Or from the main `project` object:
+
+```ts
+project.getRootDirectories(); // gets directories without a parent
+project.getDirectories(); // gets all the directories
+project.getDirectory("path/to/directory");
+project.getDirectoryOrThrow("path/to/directory");
+```
+
+### Adding
+
+On a directory:
+
+```ts
+const childDirectory = directory.addDirectoryAtPath("childDir"); // or addDirectoryAtPathIfExists
+```
+
+Or main `project` object:
+
+```ts
+const directory = project.addDirectoryAtPath("path/to/dir"); // or addDirectoryAtPathIfExists
+```
+
+### Creating
+
+On a directory
+
+```ts
+const childDir = directory.createDirectory("childDir");
+```
+
+Or main `project` object:
+
+```ts
+const directory = project.createDirectory("path/to/dir");
+```
+
+## Directory
+
+### Path and name
+
+```ts
+// returns the full path (ex. /home/david/project/)
+const path = directory.getPath();
+
+// returns only the directory name (ex. project)
+const baseName = directory.getBaseName();
+```
+
+### Parent directory
+
+```ts
+const parentDir = directory.getParent(); // or getParentOrThrow()
+```
+
+### Child directories
+
+```ts
+const childDirs = directory.getDirectories();
+```
+
+### Ancestor / Descendant
+
+Check if a directory is an ancestor or descendant of another directory:
+
+```ts setup: let grandParentDir: Directory, childDir: Directory;
+grandParentDir.isAncestorOf(childDir); // true
+childDir.isDescendantOf(grandParentDir); // true
+```
+
+Or if a directory is an ancestor of a source file:
+
+```ts setup: let grandParentDir: Directory, parentDir: Directory, childSourceFile: SourceFile;
+grandParentDir.isAncestorOf(childSourceFile); // true
+parentDir.isAncestorOf(childSourceFile); // true
+```
+
+### Source files
+
+```ts
+const sourceFiles = directory.getSourceFiles();
+const sourceFile = directory.getSourceFile("someFile.ts"); // or getSourceFileOrThrow
+const indexFile = directory.addSourceFileAtPath("index.ts"); // or addSourceFileAtPathIfExists
+const descendantSourceFiles = directory.getDescendantSourceFiles();
+
+directory.createSourceFile("someFile.ts");
+directory.createSourceFile("someFile2.ts", "// some text");
+directory.createSourceFile("someFile3.ts", writer => writer.writeLine("// some text"));
+directory.createSourceFile("someFile4.ts", { statements: [{ kind: StructureKind.Enum, name: "MyEnum" }] });
+```
+
+### Saving
+
+Save the directory to the disk and all the unsaved source files:
+
+```ts
+await directory.save();
+directory.saveSync(); // slow
+```
+
+### Emitting
+
+It's possible to only specific directories:
+
+```ts
+// always check result.getEmitSkipped() to make sure the emit was successful
+const result = await directory.emit();
+directory.emitSync(); // slow
+```
+
+Or specify the output directories (specify a path relative from the directory or an absolute paths):
+
+```ts
+directory.emit({
+  outDir: "out",
+  declarationDir: "declarations",
+});
+```
+
+And of course, specify to only emit declaration files:
+
+```ts
+directory.emit({ emitOnlyDtsFiles: true });
+```
+
+### Moving
+
+Move the directory to a new directory:
+
+```ts setup: const otherDir: Directory;
+// ex. moves C:\MyProject\dir to C:\MyProject\newDir if working directory is C:\MyProject
+directory.move("./newDir");
+// ex. moves C:\MyProject\newDir to C:\MyProject\otherDir using a relative path
+directory.move("../otherDir", { overwrite: true }); // allows overwriting (otherwise it will throw)
+// or specify an absolute path
+directory.move("C:\\finalDir");
+// or specify the directory to move to
+directory.moveToDirectory("some/directory");
+directory.moveToDirectory(otherDir);
+```
+
+### Moving Immediately
+
+Moving a directory immediately can be done by using one of the following methods:
+
+```ts
+await directory.moveImmediately("../newDir");
+// or
+directory.moveImmediatelySync("../newDir2");
+```
+
+### Copying
+
+Copy the directory to a new directory:
+
+```ts setup: const otherDir: Directory;
+// ex. copies C:\MyProject\dir to C:\MyProject\newDir
+directory.copy("../newDir");
+// allows overwriting (otherwise it will throw)
+directory.copy("../nextDir", { overwrite: true });
+// or specify an absolute path
+directory.copy("C:\\test");
+// or specify the directory to copy to
+directory.copyToDirectory("some/directory");
+directory.copyToDirectory(otherDir);
+```
+
+Note that the directory and source files, in all these cases, won't be created until calling save on the project.
+
+#### Not including untracked files
+
+When moving a directory, it will queue up a file system copy for the directory from to the directory to. If you only wish to copy the source files that are found in memory within the directory, then set the `includeUntrackedFiles` option to false:
+
+```
+directory.copy("../finalDir", { includeUntrackedFiles: false });
+```
+
+### Copying Immediately
+
+Copying a directory immediately can be done by using one of the following methods:
+
+```ts
+await directory.copyImmediately("../otherDir");
+// or
+directory.copyImmediatelySync("../otherDir2");
+```
+
+### Deleting
+
+Call:
+
+```ts
+directory.delete();
+```
+
+This will remove the directory object and all its descendant source files and directories from the main `project` object and queue it up for deletion to the file system.
+
+When you're all done your other manipulations, call `project.save()` and at that point the directory will be deleted.
+
+#### Deleting immediately
+
+If you want to delete a directory immediately from the file system, then use the following:
+
+```ts
+await directory.deleteImmediately();
+// or
+directory.deleteImmediatelySync();
+```
+
+This isn't recommended though because it could possibly leave the file system in a halfway state if your code errors before it's done.
+
+### Clearing
+
+Call:
+
+```ts
+directory.clear();
+```
+
+This will delete the directory's descendants in memory and queue a delete and mkdir operation to the file system.
+
+#### Clearing immediately
+
+If you want to do this operation immediatley to the file system, then use the following:
+
+```ts
+await directory.clearImmediately();
+// or
+directory.clearImmediatelySync();
+```
+
+This isn't recommended though because it could possibly leave the file system in a halfway state if your code errors before it's done.
+
+### Forgetting
+
+Forgets the directory from main project object without deleting it:
+
+```ts
+directory.forget();
+```
+
+Note that after doing this, the directory object and all its descendant source files and directories will not be available. If you want to use them again,
+then you will need to re-add them.
+
+### Relative File Paths
+
+It might be useful to get the relative path from one directory to another source file or directory.
+
+```ts setup: let directoryFrom: Directory, sourceFileTo: SourceFile;
+const relativePath = directoryFrom.getRelativePathTo(sourceFileTo);
+```
+
+Or to get the module specifier text from one directory to another source file or directory.
+
+```ts setup: let directoryFrom: Directory, sourceFileTo: SourceFile;
+const moduleSpecifier = directoryFrom.getRelativePathAsModuleSpecifierTo(sourceFileTo);
+```

package/vendor/ts-morph/docs/navigation/example.md

@@ -0,0 +1,50 @@
+---
+title: Navigation example
+---
+
+## Example - Navigating Within Source Files
+
+### Setup
+
+Given the following file:
+
+```ts
+// Person.ts
+
+interface Person {
+  name: string;
+  age: number;
+}
+
+export default Person;
+```
+
+And setup:
+
+```ts
+import { Project } from "ts-morph";
+
+const project = new Project();
+project.addSourceFilesAtPaths("**/*.ts");
+```
+
+### Use
+
+First you need to get the source file you would like to look at:
+
+```ts
+const sourceFile = project.getSourceFileOrThrow("Person.ts");
+```
+
+Now inspect what's inside... here's a few examples:
+
+```ts
+const hasClasses = sourceFile.getClasses().length > 0;
+const interfaces = sourceFile.getInterfaces();
+
+// person interface
+const personInterface = sourceFile.getInterface("Person")!;
+personInterface.isDefaultExport(); // returns true
+personInterface.getName(); // returns "Person"
+personInterface.getProperties(); // returns the properties
+```

package/vendor/ts-morph/docs/navigation/finding-references.md

@@ -0,0 +1,53 @@
+---
+title: Finding References
+---
+
+## Finding References
+
+Find all the references of a node by calling `.findReferences()` on an identifier or named/nameable declaration.
+
+### Example
+
+Simple example:
+
+```ts ignore-error: 1109
+const classDeclaration = ...; // get a class or some other declaration somehow
+const referencedSymbols = classDeclaration.findReferences();
+
+for (const referencedSymbol of referencedSymbols) {
+    for (const reference of referencedSymbol.getReferences()) {
+        console.log("---------")
+        console.log("REFERENCE")
+        console.log("---------")
+        console.log("File path: " + reference.getSourceFile().getFilePath());
+        console.log("Start: " + reference.getTextSpan().getStart());
+        console.log("Length: " + reference.getTextSpan().getLength());
+        console.log("Parent kind: " + reference.getNode().getParentOrThrow().getKindName());
+        console.log("\n");
+    }
+}
+```
+
+## Finding Referencing Nodes
+
+The `.findReferences()` method returns back a lot of information that might not be necessary.
+If you just want the nodes that reference the named/nameable declaration, then use the
+following method:
+
+```ts
+const nodes = classDeclaration.findReferencesAsNodes();
+```
+
+## "Go to Definition"
+
+Similar to finding references, you can also go to an identifier's definitions:
+
+```ts
+const definitions = identifier.getDefinitions();
+```
+
+Or just get the nodes:
+
+```ts
+const nodes = identifier.getDefinitionNodes();
+```

package/vendor/ts-morph/docs/navigation/getting-source-files.md

@@ -0,0 +1,59 @@
+---
+title: Getting Source Files
+---
+
+## Getting Source Files
+
+After source files are added, you will need to get them in order to navigate or make changes.
+
+### All
+
+Get all the source files:
+
+```ts
+const sourceFiles = project.getSourceFiles();
+```
+
+Or filter by glob:
+
+```ts
+// single
+const testSourceFiles = project.getSourceFiles("src/test/**/*.ts");
+// or multiple
+const nonTestSourceFiles = project.getSourceFiles([
+  "src/**/*.ts",
+  "!src/test/**/*.ts",
+]);
+```
+
+Note that the path resolution and matching is done relative to the current working directory.
+
+For example, if you load a project from another directory...
+
+```ts
+const project = new Project({
+  tsConfigFilePath: `/someDirectory/notCurrent/tsconfig.json`,
+});
+```
+
+...to match a file from that directory you need to specify a glob that matches based on the current working directory or absolute path...
+
+```ts
+const sourceFile = project.getSourceFiles(`/someDirectory/notCurrent/**/config/index.ts`);
+```
+
+### By file path
+
+Will return the first source file that matches the end of the provided file path:
+
+```ts
+const personFile = project.getSourceFile("Models/Person.ts");
+```
+
+### By condition
+
+Will return the first source file that matches the provided condition:
+
+```ts
+const fileWithFiveClasses = project.getSourceFile(f => f.getClasses().length === 5);
+```