fcis 0.1.0

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

@@ -0,0 +1,94 @@
+---
+title: Navigating the AST
+---
+
+## Navigating the AST
+
+Navigating the AST should be simple and straightforward.
+
+Right now, the best way to explore what's implemented is to look at the autocompletion/intellisense results
+or view [this report](https://github.com/dsherret/ts-morph/blob/latest/packages/ts-morph/wrapped-nodes.md).
+
+If you can't find something that means it's most likely not implemented and you should [open an issue](https://github.com/dsherret/ts-morph/issues) on GitHub.
+
+### General methods
+
+Search autocomplete for methods like `.getChildren()`, `.getParent()`, `.getFirstChildBySyntaxKind(kind)`, etc...
+
+Many exist. If you find one you would really like, then please [open an issue](https://github.com/dsherret/ts-morph/issues).
+
+### getChildren() and forEachChild(child => ...)
+
+In general, you can easily navigate the tree by using methods such as `.getClasses()`, `.getClass('MyClass')`, `.getModules()`, and so on, but in some cases you might want to get all the child nodes.
+
+In the compiler API, there exists a `node.getChildren()` method and `ts.forEachChild(node, child => { })`/`node.forEachChild(child => { })` function/method.
+
+- `.getChildren()` - Returns all the children including the all the tokens (ex. `OpenBraceToken`, `SemiColonToken` etc.).
+- `.forEachChild(child => {})` - Iterates all the child nodes that are properties of the node.
+
+[![getChildren vs forEachChild](images/getChildrenVsForEachChild.gif)](http://ts-ast-viewer.com)
+
+In ts-morph, these methods also exist and they can be used similarly to the compiler API:
+
+```ts
+const allChildren = node.getChildren();
+
+node.forEachChild(node => {
+  console.log(node.getText());
+});
+
+const classDec = node.forEachChild(node => {
+  if (Node.isClassDeclaration(node))
+    return node; // stops iterating over the children and returns this value
+  return undefined; // return a falsy value or no value to continue iterating
+});
+```
+
+### forEachDescendant
+
+If you wish to iterate all the descendants, then use the `forEachDescendant` method:
+
+```ts
+node.forEachDescendant(node => console.log(node.getText()));
+```
+
+This is especially useful when writing code that implements a visitor pattern:
+
+```ts ignore-error: 1109, setup: let sourceFiles: SourceFile[];
+interface Visitor {
+    visit(node: Node): void;
+}
+
+const myVisitors: Visitor[] = ...;
+
+for (const sourceFile of sourceFiles)
+    sourceFile.forEachDescendant(node => myVisitors.forEach(v => v.visit(node)));
+```
+
+#### Traversal Control
+
+Traversal can be controlled with the second parameter:
+
+```ts
+const result = node.forEachDescendant((node, traversal) => {
+  switch (node.getKind()) {
+    case SyntaxKind.ClassDeclaration:
+      // skips traversal of the current node's descendants
+      traversal.skip();
+      break;
+    case SyntaxKind.Parameter:
+      // skips traversal of the current node's descendants and its siblings and all their descendants
+      traversal.up();
+      break;
+    case SyntaxKind.FunctionDeclaration:
+      // stops traversal completely
+      traversal.stop();
+      break;
+    case SyntaxKind.InterfaceDeclaration:
+      // stops traversal completely and returns this value
+      return node;
+  }
+
+  return undefined;
+});
+```

package/vendor/ts-morph/docs/navigation/language-service.md

@@ -0,0 +1,23 @@
+---
+title: Language Service
+---
+
+## Language Service
+
+Get the language service by calling:
+
+```ts
+const languageService = project.getLanguageService();
+```
+
+### Underlying compiler object
+
+The underlying `ts.LanguageService` can be retrieved as follows:
+
+```ts
+const tsLanguageService = languageService.compilerObject;
+```
+
+### Use
+
+Generally you won't need to use the language service because most of the functionality is exposed as methods on other objects.

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

@@ -0,0 +1,25 @@
+---
+title: Program
+---
+
+## Program
+
+Get the program by calling:
+
+```ts
+const program = project.getProgram();
+```
+
+### Underlying compiler object
+
+The underlying `ts.Program` can be retrieved as follows:
+
+```ts
+const tsProgram = program.compilerObject;
+```
+
+**Warning:** The underlying compiler object will be discared whenever manipulation occurs. For that reason, only hold onto the underlying compiler object between manipulations.
+
+### Use
+
+Generally you won't need to use the program because most of the functionality is exposed as methods on other objects.

package/vendor/ts-morph/docs/navigation/type-checker.md

@@ -0,0 +1,33 @@
+---
+title: Type Checker
+---
+
+## Type Checker
+
+Get the type checker by calling:
+
+```ts
+const typeChecker = project.getTypeChecker();
+```
+
+### Underlying compiler object
+
+The underlying `ts.TypeChecker` can be retrieved as follows:
+
+```ts
+const tsTypeChecker = typeChecker.compilerObject;
+```
+
+**Warning:** The underlying compiler object will be discared whenever manipulation occurs. For that reason, only hold onto the underlying compiler object between manipulations.
+
+### Use
+
+Generally you won't need to use the type checker because most of the functionality is exposed as methods on other objects.
+
+### Signature Resolution
+
+Get the resolved signature of a call-like expression node (ex. call expression):
+
+```ts
+const resolvedSignature = typeChecker.getResolvedSignature(callLikeExpression);
+```

package/vendor/ts-morph/docs/setup/adding-source-files.md

@@ -0,0 +1,145 @@
+---
+title: Adding Source Files
+---
+
+## Adding Source Files
+
+You will need to populate the `project` object with source files.
+
+### By a _tsconfig.json_
+
+Source files will be added when instantiating with a `tsConfigFilePath`:
+
+```ts
+import { Project } from "ts-morph";
+
+const project = new Project({
+  tsConfigFilePath: "path/to/tsconfig.json",
+});
+```
+
+...and this can be disabled by setting `skipAddingFilesFromTsConfig: true`:
+
+```ts
+const project = new Project({
+  tsConfigFilePath: "path/to/tsconfig.json",
+  skipAddingFilesFromTsConfig: true,
+});
+```
+
+Alternatively, populate the `project` object by calling `addSourceFilesFromTsConfig`:
+
+```ts
+project.addSourceFilesFromTsConfig("path/to/tsconfig.json");
+```
+
+#### Source File Dependency Resolution
+
+By default, all the source files added to the project in the constructor via a _tsconfig.json_ will automatically be analyzed to
+include the source files they depend on. If you wish to skip this analysis step, then provide the `skipFileDependencyResolution` option:
+
+```ts
+const project = new Project({
+  tsConfigFilePath: "path/to/tsconfig.json",
+  skipFileDependencyResolution: true,
+});
+```
+
+If you are adding source files to a project in other ways and want to ensure the all the source files depended on by the added source files
+are also included in the Project, then call the `.resolveSourceFileDependencies()` after adding everything:
+
+```ts
+const project = new Project();
+
+// add everything to the project
+project.addSourceFilesFromTsConfig("dir1/tsconfig.json");
+project.addSourceFilesFromTsConfig("dir2/tsconfig.json");
+project.addSourceFilesAtPaths("dir3/**/*{.d.ts,.ts}");
+
+// optionally call this when complete to resolve and
+// add the dependent source files to the project
+project.resolveSourceFileDependencies();
+```
+
+### By file globs or file paths
+
+Specify as many file globs or file paths as you wish:
+
+```ts
+project.addSourceFilesAtPaths("folder/**/*{.d.ts,.ts}");
+project.addSourceFilesAtPaths(["folder/file.ts", "folder/otherFile.ts"]);
+project.addSourceFilesAtPaths(["**/*.ts", "!**/*.d.ts"]);
+```
+
+### By file path
+
+```ts
+const sourceFile = project.addSourceFileAtPath("path/to/file.ts"); // or addSourceFileAtPathIfExists
+```
+
+### By structure
+
+Create source files based on an object that looks like the AST of a source file:
+
+```ts
+const sourceFile = project.createSourceFile("path/to/myStructureFile.ts", {
+  statements: [{
+    kind: StructureKind.Enum,
+    name: "MyEnum",
+    members: [{
+      name: "member",
+    }],
+  }, {
+    kind: StructureKind.Class,
+    name: "MyClass",
+    // etc...
+  }],
+  // etc...
+});
+```
+
+The above would create a source file with the following text:
+
+```ts
+enum MyEnum {
+  member,
+}
+
+class MyClass {
+}
+```
+
+### By string
+
+```ts
+const fileText = "enum MyEnum {\n}\n";
+const sourceFile = project.createSourceFile("path/to/myNewFile.ts", fileText);
+```
+
+### By writer function
+
+```ts
+const sourceFile = project.createSourceFile("path/to/myOtherNewFile.ts", writer => {
+  writer
+    .writeLine("import * as ts from 'typescript';").blankLine()
+    .writeLine("export class MyClass {}");
+});
+```
+
+### Options
+
+`createSourceFile` will throw an error if the file already exists.
+To not throw an error, set the `overwrite` option to true.
+
+```ts
+const sourceFile = project.createSourceFile("path/to/myNewFile.ts", "", { overwrite: true });
+```
+
+### Note
+
+Adding source files to the project from a structure, writer function, or text will act like any other source file, but they will not be saved to the disk unless you ask it to be.
+
+```ts
+// save it to the disk if you wish:
+await sourceFile.save(); // or saveSync();
+```

package/vendor/ts-morph/docs/setup/ast-viewers.md

@@ -0,0 +1,46 @@
+---
+title: AST Viewers
+---
+
+## AST Viewers
+
+An AST viewer is a useful way to help understand the TypeScript AST for some source code.
+
+### TypeScript AST Viewer
+
+I've created this very basic web-based TypeScript AST viewer.
+
+[TypeScript AST Viewer](http://ts-ast-viewer.com)
+
+Features:
+
+- View code on left, tree in middle, and information about selected node on right.
+- View the type and symbol of the selected node.
+- Toggle the tree between `node.forEachChild(...)` and `node.getChildren()`.
+- Change compiler API versions.
+- Use some compiler objects in the browser console.
+
+[![TypeScript AST Viewer](images/ts-ast-viewer.png)](http://ts-ast-viewer.com)
+
+I will improve and add more functionality to this in the future. You can help contribute to its progress [here](https://github.com/dsherret/ts-ast-viewer).
+
+### Atom TypeScript
+
+This AST viewer gives an excellent view of the AST.
+
+1. Install [Atom](https://atom.io/).
+2. Install [atom-typescript](https://atom.io/packages/atom-typescript).
+3. Create a new typescript file.
+4. Paste in your typescript code.
+
+   ![TypeScript file](images/atom-file.png)
+
+5. Important: Ensure the current typescript document has focus.
+6. Open the command palette (Windows/Linux: `ctrl+shift+p`, Mac: `cmd+shift+p`).
+7. Type `TypeScript: Ast Full` and hit enter (or run `TypeScript: Ast` to get the ast without tokens).
+
+   ![Command Palette](images/atom-command-palette.png)
+
+8. A new tab will appear with the AST.
+
+   [![atom-typescript AST Viewer](images/atom-ast_small.png)](images/atom-ast.png)

package/vendor/ts-morph/docs/setup/diagnostics.md

@@ -0,0 +1,109 @@
+---
+title: Diagnostics
+---
+
+## Diagnostics
+
+Diagnostics (compile errors) can be retrieved on the project or on source files:
+
+```ts
+const diagnostics = project.getPreEmitDiagnostics();
+
+// or on a source file
+const sourceFileDiagnostics = sourceFile.getPreEmitDiagnostics();
+```
+
+The pre-emit diagnostics are the syntactic, semantic, global, options, config file parsing, and if enabled the declaration diagnostics.
+
+### Formatting for Output
+
+To nicely output the diagnostics, use `project.formatDiagnosticsWithColorAndContext`:
+
+```ts
+const diagnostics = project.getPreEmitDiagnostics();
+
+console.log(project.formatDiagnosticsWithColorAndContext(diagnostics));
+```
+
+### Diagnostic
+
+#### Message text
+
+Returned message text could be a `string` or a `DiagnosticMessageChain`:
+
+```ts
+const message = diagnostic.getMessageText();
+```
+
+#### Source file
+
+Source file the diagnostic occurs in:
+
+```ts
+const sourceFile = diagnostic.getSourceFile(); // returns: SourceFile | undefined
+```
+
+#### Start, line number, & length
+
+Position in the file, the line number, and length of the diagnostic:
+
+```ts
+const start = diagnostic.getStart(); // returns: number
+const lineNumber = diagnostic.getLineNumber(); // returns: number
+const length = diagnostic.getLength(); // returns: number
+```
+
+#### Category
+
+Categories can be warnings, errors, or just messages.
+
+```ts
+const category = diagnostic.getCategory(); // returns: DiagnosticCategory
+```
+
+#### Code
+
+This is the error code number:
+
+```ts
+const code = diagnostic.getCode(); // returns: number
+```
+
+#### Source
+
+todo: I don't know what this is, but it's available to get from the diagnostic.
+
+```ts
+const source = diagnostic.getSource(); // returns: string | undefined
+```
+
+### DiagnosticMessageChain
+
+A diagnostic message chain (DMC) will be returned by `diagnostic.getMessageText()` in certain scenarios.
+
+According to the typescript compiler:
+
+```
+/**
+* A linked list of formatted diagnostic messages to be used as part of a multiline message.
+* It is built from the bottom up, leaving the head to be the "main" diagnostic.
+* While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage,
+* the difference is that messages are all preformatted in DMC.
+*/
+```
+
+The properties of a DMC are similar to a Diagnostic:
+
+```ts
+const messageText = dmc.getMessageText(); // returns: string
+const category = dmc.getCategory(); // returns: DiagnosticCategory
+const code = dmc.getCode(); // returns: number
+```
+
+#### Next DMC in linked list
+
+Call `.getNext()`:
+
+```ts
+const next = dmc.getNext(); // returns: DiagnosticMessageChain | undefined
+```

package/vendor/ts-morph/docs/setup/file-system.md

@@ -0,0 +1,106 @@
+---
+title: File System
+---
+
+## File System
+
+By default, the library will use the local file system based on the current working directory. In most scenarios, you won't have to bother with what's outlined here, but it may be useful in some scenarios (for example, using an in-memory file system is useful for mocking the file system for testing purposes).
+
+### Current File System Object
+
+```ts
+import { Project } from "ts-morph";
+const project = new Project();
+
+const fs = project.getFileSystem(); // returns: FileSystemHost
+```
+
+This file system object can be used to interact with the current file system. The methods available on it are very obvious and not worth explaining
+here (ex. `writeFile(filePath: string, fileText: string): Promise<void>`, `readFile(filePath: string): Promise<string>`, `readFileSync(filePath: string): string`, etc..).
+
+### In-Memory File System
+
+If you want to use a file system that is stored in memory, specify that when creating a `Project` instance:
+
+```ts
+import { Project } from "ts-morph";
+
+const project = new Project({ useInMemoryFileSystem: true });
+const fs = project.getFileSystem();
+
+const sourceFile = project.createSourceFile("file.ts", "console.log(5);");
+sourceFile.saveSync();
+console.log(fs.readFileSync("file.ts")); // outputs: "console.log(5);"
+```
+
+The current working directory on this file system will be `/`.
+
+This file system can also be imported and created via the `InMemoryFileSystemHost` export.
+
+#### Remember: The Default Script Target is `ES5`
+
+You may wonder why certain standard types are `any` when using an in memory file system:
+
+```ts
+const project = new Project({ useInMemoryFileSystem: true });
+const sourceFile = project.createSourceFile(
+  "index.ts",
+  `const mySet = new Set<string>();`,
+);
+const mySetDecl = sourceFile.getVariableDeclarationOrThrow("mySet");
+console.log(mySetDecl.getType().getText()); // any
+```
+
+This is because, the `lib` compiler option must be specified, similar to when you use `tsc`:
+
+```ts setup: let mySetDecl: Node;
+const project = new Project({
+  useInMemoryFileSystem: true,
+  compilerOptions: {
+    lib: ["lib.es2015.d.ts"],
+  },
+});
+/// ...omitted... same as above...
+console.log(mySetDecl.getType().getText()); // Set<string>, good
+```
+
+Or you may specify a target that will implicitly load in the lib files that you need:
+
+```ts setup: let mySetDecl: Node;
+import { Project, ts } from "ts-morph";
+
+const project = new Project({
+  useInMemoryFileSystem: true,
+  compilerOptions: {
+    target: ts.ScriptTarget.ES2015,
+  },
+});
+/// ...omitted... same as above...
+console.log(mySetDecl.getType().getText()); // Set<string>, good
+```
+
+Note that if you want to include all the lib files, you may specify `lib.esnext.full.d.ts` as a `lib` option:
+
+```ts
+const project = new Project({
+  useInMemoryFileSystem: true,
+  compilerOptions: {
+    lib: ["lib.esnext.full.d.ts"],
+  },
+});
+```
+
+### Custom File System
+
+It's possible to use your own custom file system by implementing the `FileSystemHost` interface then passing in an instance of this when creating a new `Project` instance:
+
+```ts ignore-error: 2420, 2345, 2740
+import { FileSystemHost, Project } from "ts-morph";
+
+class MyCustomFileSystem implements FileSystemHost {
+  // implement it
+}
+
+const fs = new MyCustomFileSystem();
+const project = new Project({ fileSystem: fs });
+```

package/vendor/ts-morph/docs/setup/index.md

@@ -0,0 +1,94 @@
+---
+title: Instantiating
+---
+
+## Instantiating
+
+Use the `Project` named export from `"ts-morph"`:
+
+```ts
+import { Project } from "ts-morph";
+
+const project = new Project();
+```
+
+### Compiler options
+
+```ts
+import { Project, ScriptTarget } from "ts-morph";
+
+const project = new Project({
+  compilerOptions: {
+    target: ScriptTarget.ES3,
+  },
+});
+```
+
+### tsconfig.json
+
+If you would like to manually specify the path to a _tsconfig.json_ file then specify that:
+
+```ts
+const project = new Project({
+  tsConfigFilePath: "path/to/tsconfig.json",
+});
+```
+
+_Note:_ You can override any `tsconfig.json` options by also providing a `compilerOptions` object.
+
+For your convenience, this will automatically add all the associated source files from the _tsconfig.json_. If you don't wish to do that, then you will need to set `skipAddingFilesFromTsConfig` to `true`:
+
+```ts
+const project = new Project({
+  tsConfigFilePath: "path/to/tsconfig.json",
+  skipAddingFilesFromTsConfig: true,
+});
+```
+
+### Custom Module Resolution
+
+Custom module resolution can be specified by providing a resolution host factory function. This also supports providing custom type reference directive resolution.
+
+For example:
+
+```ts
+import { Project, ts } from "ts-morph";
+
+// this is deno style module resolution (ex. `import { MyClass } from "./MyClass.ts"`)
+const project = new Project({
+  resolutionHost: (moduleResolutionHost, getCompilerOptions) => {
+    return {
+      resolveModuleNames: (moduleNames, containingFile) => {
+        const compilerOptions = getCompilerOptions();
+        const resolvedModules: ts.ResolvedModule[] = [];
+
+        for (const moduleName of moduleNames.map(removeTsExtension)) {
+          const result = ts.resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionHost);
+          if (result.resolvedModule)
+            resolvedModules.push(result.resolvedModule);
+        }
+
+        return resolvedModules;
+      },
+    };
+
+    function removeTsExtension(moduleName: string) {
+      if (moduleName.slice(-3).toLowerCase() === ".ts")
+        return moduleName.slice(0, -3);
+      return moduleName;
+    }
+  },
+});
+```
+
+### `libFolderPath`
+
+By default, ts-morph uses a fake folder path at `/node_modules/typescript/lib` to serve the TypeScript lib.d.ts files from memory.
+
+If you do not want this behaviour, you may specify an actual folder to get the lib files from the file system from:
+
+```ts
+const project = new Project({
+  libFolderPath: "./node_modules/typescript/lib",
+});
+```