fcis 0.1.0

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

@@ -0,0 +1,136 @@
+---
+title: Manipulating Source Files
+---
+
+## Manipulating Source Files
+
+Most information about manipulation can be found in the [Details](../details) section. This section only contains general information about manipulation.
+
+### Saving Changes
+
+All moves, copies, and deletes won't be propagated to the underlying file system until `save()` is called on the main `project` object.
+
+```ts
+import { Project } from "ts-morph";
+
+const project = new Project();
+
+// ...lots of code here that manipulates, copies, moves, and deletes files...
+
+// when you're all done, call this and it will save everything to the file system
+await project.save();
+```
+
+The above is recommended because it means if your code errors halfway through, the files won't be in a halfway state. However, there's always a way to save, move, copy, and delete while immediately having these changes happen on the underlying file system. For example:
+
+```ts
+// or use the synchronous alternatives (ex. saveSync())
+await sourceFile.save();
+await sourceFile.deleteImmediately();
+await sourceFile.copyImmediately("copiedFile.ts");
+await sourceFile.moveImmediately("movedFile.ts");
+
+await directory.save();
+await directory.deleteImmediately();
+await directory.copyImmediately("CopiedDir");
+await directory.moveImmediately("MovedDir");
+```
+
+### Replacing any node with new text
+
+Use the `.replaceWithText(...)` method that exists on any node.
+
+This will replace the text from the `Node#getStart(true)` position (start position with js docs) to `Node#getEnd()`. Use `Node#getText(true)` to get all the text that will be replaced.
+
+#### Example
+
+Given the following code:
+
+```ts setup: let Some: any;
+let myVariable = Some.Property.Access.Expression;
+```
+
+You can replace the property access expression with new text by doing the following:
+
+```ts
+const originalInitializer = sourceFile.getVariableDeclarations()[0].getInitializerOrThrow();
+const newInitializer = originalInitializer.replaceWithText("MyReference");
+```
+
+That will make the source file hold the following text:
+
+```ts setup: let MyReference: any;
+let myVariable = MyReference;
+```
+
+Note that `originalInitializer` will be forgotten after calling `.replaceWithText(...)` on it—an error will be thrown if you try to use it.
+You will have to use the new node returned by that method.
+
+### Adding, inserting, and removing statements
+
+Statements can be added, inserted, or removed from nodes with a body (ex. functions, methods, namespaces, source files).
+
+```ts
+// add statements
+const statements = sourceFile.addStatements("console.log(5);\nconsole.log(6);");
+// insert statements (index is the child index to insert at)
+const statements = sourceFile.insertStatements(3, "console.log(5);\nconsole.log(6);");
+// remove statements
+sourceFile.removeStatements([1, 3]); // removes statements from index 1 to 3
+sourceFile.removeStatement(1); // removes statement at index 1
+```
+
+When adding or inserting, you can also write using a [code writer](code-writer):
+
+```ts
+functionDeclaration.addStatements(writer => {
+  writer.write("if (true)").block(() => {
+    writer.write("something;");
+  });
+});
+```
+
+### Inserting, replacing, and removing any text
+
+In some scenarios, a simple to use API might not have been implemented. If you find that's the case, open an issue on GitHub.
+
+In the meantime, you can insert, replace, and remove text using the following methods, but _generally you will want to avoid using these if possible_:
+
+```ts
+// insert text
+sourceFile.insertText(0, writer => writer.writeLine("// some comment")); // or provide a string
+// replace text
+sourceFile.replaceText([3, 7], "a"); // "// a comment\n"
+// remove text
+sourceFile.removeText(sourceFile.getPos(), sourceFile.getEnd());
+```
+
+These methods are also available on any node that has a body (functions, classes, enums, etc.)
+
+#### **Warning**
+
+If you use `insertText`, `replaceText`, or `removeText`, all previously navigated descendants of the node will be forgotten and not be available for use—an error will be thrown
+if you try to use them. You will have to renavigate to those nodes.
+
+For example:
+
+```ts
+let classDeclaration = sourceFile.addClass({ name: "MyClass" });
+sourceFile.insertText(0, "// some comment\n");
+
+// this will throw...
+classDeclaration.getInstanceProperties();
+
+// you'll need to get the reference again:
+classDeclaration = sourceFile.getClass("MyClass")!;
+```
+
+## Code Fixes
+
+There are a variety of useful code fixes and refactors such as:
+
+- `SourceFile#organizeImports()`
+- `SourceFile#fixMissingImports()`
+- `SourceFile#fixUnusedIdentifiers()`
+
+Check more details on the [source files details page](../details/source-files).

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

@@ -0,0 +1,14 @@
+---
+title: Order
+---
+
+## Order
+
+Change the order of certain nodes using the `.setOrder(newIndex: number)` method.
+
+```ts
+const interfaceDeclaration = sourceFile.getInterfaceOrThrow("MyInterface");
+interfaceDeclaration.setOrder(2);
+```
+
+Notice: Right now this is not supported on comma separated nodes. See [Issue #44](https://github.com/dsherret/ts-morph/issues/44) for more information.

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

@@ -0,0 +1,222 @@
+---
+title: Performance
+---
+
+## Performance
+
+There's a lot of opportunity for performance improvements. The library originally started off favouring correctness, but it's now starting to switch to improving performance.
+
+[View Issues](https://github.com/dsherret/ts-morph/labels/performance)
+
+### Manipulations are slow...
+
+Right now with every manipulation the following occurs:
+
+1. The file text is updated.
+2. The new text is parsed and a new AST is created using the compiler API.
+3. The previously wrapped nodes are backfilled with new compiler nodes.
+
+This might not be too bad when working with small to medium sized files, but large files may take a bit of time. If you find it's too slow, then I recommend reading the performance tips below.
+
+Note: I'm working on eliminating the need to do a complete parse of the source file between manipulations. Once implemented these performance tips won't be necessary.
+
+### Performance Tip: Work With Structures Instead
+
+Structures are simplified ASTs. You can get a huge performance improvement by working with structures as much as possible. This is especially useful to do if you are code generating.
+
+Example:
+
+```ts
+// this code will get a structure from declarations.ts, make all the descendants not be exported,
+// then create a new file called private.ts from that structure
+import { forEachStructureChild, SourceFileStructure, StructureKind, Structures, Structures } from "ts-morph";
+
+const project = new Project({ tsConfigFilePath: "tsconfig.json" });
+const classesFile = project.getSourceFileOrThrow("declarations.ts");
+const classesFileStructure = classesFile.getStructure();
+
+removeExports(classesFileStructure);
+
+project.createSourceFile("private.ts", classesFileStructure);
+
+function removeExports(structure: Structures) {
+  forEachStructureChild(structure, removeExports);
+
+  if (Structure.isExportable(structure))
+    structure.isExported = false;
+}
+```
+
+Read more in [structures](structures.md).
+
+### Performance Tip: Batch operations
+
+You can reduce the amount of parsing that needs to happen by batching operations.
+
+For example, instead of writing code like this:
+
+```ts setup: const classStructures: ClassDeclarationStructure[];
+for (const classStructure of classStructures)
+  sourceFile.addClass(classStructure);
+```
+
+Write this instead:
+
+```ts setup: const classStructures: ClassDeclarationStructure[];
+sourceFile.addClasses(classStructures);
+```
+
+### Performance Tip: Analyze then Manipulate
+
+If the code analysis is using types, symbols type checker, or program, then a large performance improvement can be gained by doing an initial analysis of the code first, then afterwards carrying out the manipulations.
+
+For example, given the following code:
+
+```ts setup: const sourceFiles: SourceFile[]; const someCheckOnSymbol: any;
+for (const sourceFile of sourceFiles) {
+  for (const classDec of sourceFile.getClasses()) {
+    if (someCheckOnSymbol(classDec.getSymbolOrThrow()))
+      classDec.remove();
+  }
+}
+```
+
+Write it this way instead:
+
+```ts setup: const sourceFiles: SourceFile[]; const someCheckOnSymbol: any;
+for (const classDec of getClassesToRemove())
+  classDec.remove();
+
+function getClassesToRemove() {
+  const classesToRemove: ClassDeclaration[] = [];
+
+  for (const sourceFile of sourceFiles) {
+    for (const classDec of sourceFile.getClasses()) {
+      if (someCheckOnSymbol(classDec.getSymbolOrThrow()))
+        classesToRemove.push(classDec);
+    }
+  }
+
+  return classesToRemove;
+}
+```
+
+This is because the program is reset between manipulations.
+
+### Tracking Nodes - Overview
+
+This library makes manipulations easy for you by keeping track of how the underlying syntax tree changes between manipulations.
+
+Behind the scenes, when you manipulate the AST:
+
+1. A new source file is created using the TypeScript compiler.
+2. The previously navigated nodes have their underlying compiler nodes replaced with the new compiler nodes.
+
+It's why you can do this:
+
+```ts
+// sourcefile contains: interface Person { name: string; }
+const personInterface = sourceFile.getInterfaceOrThrow("Person");
+const nameProperty = personInterface.getPropertyOrThrow("name");
+nameProperty.setType("number");
+nameProperty.getText(); // "name: number;"
+```
+
+Instead of having to renavigate the tree after each manipulation:
+
+```ts
+// thankfully the library does not work this way
+let personInterface = sourceFile.getInterfaceOrThrow("Person");
+let nameProperty = personInterface.getPropertyOrThrow("name");
+nameProperty.setType("number");
+nameProperty.getText(); // "name: string;"
+personInterface = sourceFile.getInterfaceOrThrow("Person");
+nameProperty = personInterface.getPropertyOrThrow("name");
+nameProperty.getText(); // "name: number;"
+```
+
+When thinking about performance, the key point here is that if you have a lot of previously navigated nodes and a very large file, then manipulation might start to become sluggish.
+
+#### Forgetting Nodes (Advanced)
+
+The main way to improve performance when manipulating, is to "forget" a node when you're done with it.
+
+```ts setup: let personInterface: InterfaceDeclaration;
+personInterface.forget();
+
+// or to only forget a node's descendants that are currently in the wrapped cache
+sourceFile.forgetDescendants();
+```
+
+That will stop tracking the node and all its previously navigated descendants (ex. in this case, `nameProperty` as well).
+It won't be updated when manipulation happens again. Note that after doing this, the node will throw an error if one of its properties or methods is accessed.
+
+#### Forget Blocks (Advanced)
+
+It's possible to make sure all created nodes within a block are forgotten:
+
+```ts
+import { ClassDeclaration, InterfaceDeclaration, ModuleDeclaration, Project } from "ts-morph";
+
+const project = new Project();
+const text = "namespace Namespace { interface Interface {} class Class {} }";
+const sourceFile = project.createSourceFile("file.ts", text);
+
+let moduleDeclaration: ModuleDeclaration;
+let interfaceDeclaration: InterfaceDeclaration;
+let classDeclaration: ClassDeclaration;
+
+project.forgetNodesCreatedInBlock(remember => {
+  moduleDeclaration = sourceFile.getModuleOrThrow("Namespace");
+  interfaceDeclaration = moduleDeclaration.getInterfaceOrThrow("Interface");
+  classDeclaration = moduleDeclaration.getClassOrThrow("Class");
+
+  // you can mark nodes to remember outside the scope of this block...
+  // this will remember the specified node and all its ancestors
+  remember(interfaceDeclaration); // or pass in multiple nodes
+});
+
+moduleDeclaration.getText(); // ok, child was implicitly marked to remember
+interfaceDeclaration.getText(); // ok, was explicitly marked to remember
+classDeclaration.getText(); // throws, was forgotten
+
+// alternatively, return the node to remember it
+const node = project.forgetNodesCreatedInBlock(() => {
+  const classDec = sourceFile.getClassOrThrow("MyClass");
+  // ...do a lot of stuff...
+  return classDec;
+});
+
+node.getText(); // ok
+```
+
+Also, do not be concerned about nesting forget blocks. That is perfectly fine to do:
+
+```ts
+project.forgetNodesCreatedInBlock(() => {
+  moduleDeclaration = sourceFile.getModuleOrThrow("Namespace");
+  interfaceDeclaration = moduleDeclaration.getInterfaceOrThrow("Interface");
+
+  project.forgetNodesCreatedInBlock(remember => {
+    classDeclaration = moduleDeclaration.getClassOrThrow("Class");
+    remember(moduleDeclaration);
+  });
+
+  classDeclaration.getText(); // throws, was forgotten outside the block above
+  interfaceDeclaration.getText(); // ok, hasn't been forgotten yet
+});
+
+moduleDeclaration.getText(); // ok, was marked to remember in one of the blocks
+interfaceDeclaration.getText(); // throws, was forgotten
+classDeclaration.getText(); // throws, was forgotten
+```
+
+##### Async
+
+This method supports async and await:
+
+```ts
+await project.forgetNodesCreatedInBlock(async remember => {
+  // do stuff
+});
+```

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

@@ -0,0 +1,31 @@
+---
+title: Removing
+---
+
+## Removing
+
+Given the source file for following code:
+
+```ts
+enum MyEnum {
+  myMember,
+}
+```
+
+Removing can be done as follows:
+
+```ts
+const member = sourceFile.getEnum("MyEnum")!.getMember("myMember")!;
+member.remove();
+```
+
+So the file above would now contain the following code:
+
+```ts
+enum MyEnum {
+}
+```
+
+### Support
+
+Currently removing is implemented individually for each kind of node. In general this will work for many kind of nodes, including methods, properties, constructors, parmeters, statements, declarations. Nevertheless, if you find that `remove()` method is not implemented for a particular kind of Node, please open an issue on github.

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

@@ -0,0 +1,106 @@
+---
+title: Renaming
+---
+
+## Renaming
+
+Given the source file for following code:
+
+```ts
+enum MyEnum {
+  myMember,
+}
+const myVar = MyEnum.myMember;
+```
+
+Renaming can be done as follows:
+
+```ts
+const myEnum = sourceFile.getEnum("MyEnum")!;
+myEnum.rename("NewEnum");
+```
+
+Which will rename all usages of `MyEnum` to `NewEnum` across _all_ files.
+
+So the file above would now contain the following code:
+
+```ts
+enum NewEnum {
+  myMember,
+}
+
+const myVar = NewEnum.myMember;
+```
+
+### Renaming in comments and strings
+
+Set the `renameInComments` and `renameInStrings` options to `true` (they are `false` by default):
+
+```ts setup: let myEnum: EnumDeclaration;
+myEnum.rename("SomeOtherName", {
+  renameInComments: true,
+  renameInStrings: true,
+});
+```
+
+### Renaming with prefix and suffix text
+
+**Note:** This feature is only supported when using TypeScript 3.4+
+
+By default, renames will not change shorthand property assignments or add aliases to import & export specifiers.
+
+For example, renaming the `a` variable declaration to `b`...
+
+```ts
+const a = 5;
+const x = { a };
+
+export { a };
+```
+
+...will do the following:
+
+```ts
+const b = 5;
+const x = { b };
+
+export { b };
+```
+
+This behaviour can be changed by enabling the `usePrefixAndSuffixText` setting, which will do the following:
+
+```ts
+const b = 5;
+const x = { a: b };
+
+export { b as a };
+```
+
+This behaviour change can be specified when renaming:
+
+```ts setup: let varA: VariableDeclaration;
+varA.rename("SomeOtherName", {
+  usePrefixAndSuffixText: true,
+});
+```
+
+Or globally:
+
+```ts
+const project = new Project({
+  manipulationSettings: {
+    usePrefixAndSuffixTextForRename: true,
+  },
+});
+// or
+project.manipulationSettings.set({
+  usePrefixAndSuffixTextForRename: true,
+});
+```
+
+### Renaming Files or Directories
+
+See:
+
+- [Moving Files](../details/source-files#move)
+- [Moving Directories](../navigation/directories#moving)

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

@@ -0,0 +1,76 @@
+---
+title: Manipulation Settings
+---
+
+## Manipulation Settings
+
+The manipulation settings can be set when creating the main `Project` object:
+
+```ts
+import { IndentationText, NewLineKind, Project, QuoteKind } from "ts-morph";
+
+const project = new Project({
+  // these are the defaults
+  manipulationSettings: {
+    // TwoSpaces, FourSpaces, EightSpaces, or Tab
+    indentationText: IndentationText.FourSpaces,
+    // LineFeed or CarriageReturnLineFeed
+    newLineKind: NewLineKind.LineFeed,
+    // Single or Double
+    quoteKind: QuoteKind.Double,
+    // Whether to change shorthand property assignments to property assignments
+    // and add aliases to import & export specifiers (see more information in
+    // the renaming section of the documentation).
+    usePrefixAndSuffixTextForRename: false,
+    // Whether to use trailing commas in multi-line scenarios where trailing
+    // commas would be used.
+    useTrailingCommas: false,
+  },
+});
+```
+
+You can only provide a partial of these settings if you wish:
+
+```ts
+const project = new Project({
+  manipulationSettings: { indentationText: IndentationText.TwoSpaces },
+});
+```
+
+### Details
+
+Get more details about the settings by looking at the `manipulationSettings` property on the main `Project` object:
+
+```ts
+project.manipulationSettings.getIndentationText();
+project.manipulationSettings.getNewLineKind();
+project.manipulationSettings.getQuoteKind();
+project.manipulationSettings.getUsePrefixAndSuffixTextForRename();
+```
+
+### Updating
+
+You can update these settings later if you wish by using the `set` method:
+
+```ts
+// set only one
+project.manipulationSettings.set({ quoteKind: QuoteKind.Single });
+
+// or multiple
+project.manipulationSettings.set({
+  quoteKind: QuoteKind.Single,
+  indentationText: IndentationText.TwoSpaces,
+});
+```
+
+### Formatting
+
+There are some additional manipulation settings that are taken from the `ts.FormatCodeSettings`.
+They will slowly be supported and added to the manipulation settings. For example:
+
+```ts
+project.manipulationSettings.set({
+  // only one for now... will add more in the future
+  insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false, // default: true
+});
+```

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

@@ -0,0 +1,117 @@
+---
+title: Structures
+---
+
+## Structures
+
+Simplified AST representations called _structures_ can be retreived from and used to set many `Node` objects.
+
+### Getting structure
+
+To get the structure of a node, call `node.getStructure()`.
+
+```ts
+// example with a class declaration, but this also works on interfaces, enums, and many other nodes.
+const classStructure = classDeclaration.getStructure(); // returns: ClassDeclarationStructure
+```
+
+In the example above, a class declaration like the following...
+
+```ts
+export class MyClass {
+  myProp = 5;
+}
+```
+
+...would return the following structure object similar to the following:
+
+```js
+{
+    isAbstract: false,
+    isExported: true,
+    name: "MyClass",
+    typeParameters: [],
+    constructors: [],
+    properties: [{
+        name: "myProp",
+        initializer: "5",
+        type: undefined,
+        isReadonly: false,
+        isStatic: false
+    }],
+    methods: []
+}
+```
+
+### Setting with structure
+
+It's also possible to set the structure of a node with an existing structure:
+
+```ts setup: const classStructure = {};
+classDeclaration.set(classStructure);
+// sets the name
+classDeclaration.set({ name: "NewName" });
+// sets the properties
+classDeclaration.set({ properties: [{ name: "newProperty" }] });
+```
+
+Or you can use the `addX` or `insertX` methods with a structure:
+
+```ts
+sourceFile.addClass({ name: "NewClass", ...classDeclaration.getStructure() });
+```
+
+### Traversing structures
+
+#### `Structure` type guards
+
+Similar to static methods found on `Node`, there is also a `Structure` export that you can use to check certain information about a structure.
+
+For example:
+
+```ts setup: const structure: Structures;
+import { Structure } from "ts-morph";
+
+// ...etc...
+
+if (Structure.isExportable(structure))
+  structure.isExported = false;
+```
+
+#### `forEachStructureChild`
+
+Similar to the compiler API's `forEachChild`, there is a `forEachStructureChild` method in ts-morph for navigating over a structure's children.
+
+For example:
+
+```ts
+import { forEachStructureChild, SourceFileStructure, Structure } from "ts-morph";
+
+const structure: SourceFileStructure = {
+  kind: StructureKind.SourceFile,
+  statements: [{
+    kind: StructureKind.Function,
+    name: "myFunction",
+    parameters: [{ name: "myParam" }],
+  }],
+};
+
+forEachStructureChild(structure, child => {
+  if (Structure.hasName(child))
+    console.log(child.name);
+});
+```
+
+Outputs: `"myFunction"`
+
+##### Structures with no kind
+
+Some structures have optional kinds. For example, in `parameters: [{ name: "myParam" }]` above, specifying `kind: StructureKind.Parameter` in the parameter would be unnecessarily repetitive. However, when using `forEachStructureChild`, you probably want to know the `kind` of the structure in order to do certain operations. For this reason, `forEachStructureChild` will automatically add the correct `kind` property to structures that don't have one.
+
+##### Finding a child structure
+
+Note that unlike ts-morph's `forEachChild`, this function acts like the `forEachChild` in the compiler API and will return any truthy value returned in the second argument's function:
+
+```ts setup: const structure: SourceFileStructure;
+const firstClassDecStructure = forEachStructureChild(structure, child => Structure.isClass(child) ? child : undefined);
+```