fcis 0.1.0

package/vendor/ts-morph/docs/details/object-literal-expressions.md

@@ -0,0 +1,106 @@
+---
+title: Object Literal Expressions
+---
+
+## Object Literal Expressions
+
+Object literal expressions look like the [initializer](initializers) for this variable declaration:
+
+```ts
+const obj = {
+  propertyAssignment: 5,
+  shorthandPropertyAssignment,
+  ...spreadAssignment,
+  get getAccessor() {
+    return 5;
+  },
+  set setAccessor(value: number) {
+    // do something
+  },
+  method() {
+    return "some string";
+  },
+};
+```
+
+### Properties
+
+Once you have retrieved the object literal expression, get it's properties via:
+
+```ts
+const properties = objectLiteralExpression.getProperties();
+// or
+const property = objectLiteralExpression.getProperty("propertyAssignment");
+// or
+const spreadAssignment = objectLiteralExpression.getProperty(
+  p => p.getText() === "...spreadAssignment",
+);
+// or
+const method = objectLiteralExpression.getPropertyOrThrow("method");
+```
+
+### Property Assignments
+
+Add a property assignment via the `insertPropertyAssignment`, `insertPropertyAssignments`, `addPropertyAssignment`, or `addPropertyAssignments` methods.
+
+```ts
+const propertyAssignment = objectLiteralExpression.addPropertyAssignment({
+  name: "propertyAssignment",
+  initializer: "5",
+});
+```
+
+### Shorthand Property Assignments
+
+Add a shorthand property assignment via the `insertShorthandPropertyAssignment`, `insertShorthandPropertyAssignments`,
+`addShorthandPropertyAssignment`, or `addShorthandPropertyAssignments` methods.
+
+```ts
+const shorthandPropertyAssignment = objectLiteralExpression.addShorthandPropertyAssignment({
+  name: "shorthandPropertyAssignment",
+});
+```
+
+### Spread Assignments
+
+Add a spread assignment via the `insertSpreadAssignment`, `insertSpreadAssignments`, `addSpreadAssignment`, or `addSpreadAssignments` methods.
+
+```ts
+const spreadAssignment = objectLiteralExpression.addSpreadAssignment({ expression: "spreadAssignment" });
+```
+
+### Accessors
+
+Add get and set accessors via the `insertGetAccessor`, `insertGetAccessors`, `addGetAccessor`, `addGetAccessors`, or similarly named methods for set accessors.
+
+```ts
+const getAccessor = objectLiteralExpression.addGetAccessor({
+  name: "someNumber",
+  returnType: "number",
+  statements: ["return someNumber;"],
+});
+const setAccessor = objectLiteralExpression.addSetAccessor({
+  name: "someNumber",
+  parameters: [{ name: "value", type: "number" }],
+  statements: ["someNumber = value;"],
+});
+```
+
+### Methods
+
+Add a method via the `insertMethod`, `insertMethods`, `addMethod`, or `addMethods` methods.
+
+```ts
+const method = objectLiteralExpression.addMethod({
+  name: "method",
+  statements: [`return "some string";`],
+});
+```
+
+### Removing
+
+Remove a member by calling `.remove()` on it.
+
+```ts setup: const obj: ObjectLiteralExpression;
+obj.getPropertyOrThrow("prop1").remove();
+```

package/vendor/ts-morph/docs/details/parameters.md

@@ -0,0 +1,64 @@
+---
+title: Parameters
+---
+
+## Parameters
+
+Parameters can be retreived from nodes by calling `getParameters()`:
+
+```ts
+const parameters = functionDeclaration.getParameters();
+```
+
+### Inserting/Adding
+
+Insert or add parameters by calling `insertParameter()`, `insertParameters()`, `addParameter()`, or `addParameters()`.
+
+For example:
+
+```ts
+const parameter = functionDeclaration.insertParameter(1, {
+  name: "param1",
+  type: "string",
+});
+```
+
+### Removing
+
+Remove a parameter by calling `.remove()` on it:
+
+```ts
+parameter.remove();
+```
+
+### Rest parameter
+
+Tell if a parameter is a rest parameter:
+
+```ts
+const isRestParameter = parameter.isRestParameter(); // returns: boolean
+```
+
+Or set a parameter as a rest parameter:
+
+```ts
+parameter.setIsRestParameter(true);
+```
+
+### Parameter Property
+
+Constructor parameters may be properties when they have a scope and/or are readonly. You can tell if one is by calling:
+
+```ts
+const isParameterProperty = parameter.isParameterProperty(); // returns: boolean
+```
+
+### Optional
+
+A parameter can be optional if it is marked so with a question mark, is a rest parameter, or has an initializer.
+
+`isOptional()` can be used to tell if any of these are true:
+
+```ts
+const isOptional = parameter.isOptional(); // returns: boolean
+```

package/vendor/ts-morph/docs/details/signatures.md

@@ -0,0 +1,41 @@
+---
+title: Signatures
+---
+
+## Signatures
+
+### Type Parameters
+
+```ts
+const typeParams = signature.getTypeParameters(); // returns: TypeParameter[]
+```
+
+### Parameters
+
+```ts
+const params = signature.getParameters(); // returns: Symbol[]
+```
+
+### Return Type
+
+```ts
+const returnType = signature.getReturnType();
+```
+
+### Documentation Comments
+
+```ts
+const docs = signature.getDocumentationComments();
+```
+
+### JS Doc Tags
+
+```ts
+const tags = signature.getJsDocTags();
+```
+
+### Declaration
+
+```ts
+const declaration = signature.getDeclaration();
+```

package/vendor/ts-morph/docs/details/source-files.md

@@ -0,0 +1,292 @@
+---
+title: Source Files
+---
+
+## Source Files
+
+Source files are the root nodes of the AST. They can be created or added to a `Project` instance
+by following the instructions at [Adding Source Files](../setup/adding-source-files).
+
+### File path and name
+
+Use:
+
+```ts
+// returns the file path (ex. /home/david/file.ts)
+sourceFile.getFilePath();
+
+// returns only the file name (ex. file.ts)
+sourceFile.getBaseName();
+```
+
+### Other Information
+
+Check if it's a declaration file:
+
+```ts
+sourceFile.isDeclarationFile(); // returns: boolean
+```
+
+Check if it was discovered from an external module:
+
+```ts
+sourceFile.isFromExternalLibrary();
+```
+
+Check if it's a descendant of a `node_modules` directory:
+
+```ts
+sourceFile.isInNodeModules();
+```
+
+### Save
+
+Save a source file to the file system using one of the following commands:
+
+```ts
+await sourceFile.save();
+sourceFile.saveSync();
+```
+
+Note: This does not emit the files (see [Emitting](../emitting.md)).
+
+### Unsaved files
+
+Use the `sourceFile.isSaved()` method that will tell you if the file is saved to the file system.
+
+### Delete
+
+The `sourceFile.delete()` method will queue up deletions to the file system. When done call `project.save()`. For example:
+
+```ts
+import { Project } from "ts-morph";
+
+// queue up all the source files to be deleted
+const project = new Project();
+project.addSourceFilesAtPaths("folder/**/*.ts");
+
+project.getSourceFileOrThrow("someFile.ts").delete();
+project.getSourceFileOrThrow("someOtherFile.ts").delete();
+
+// after you're all done, finally save your changes to the file system
+await project.save();
+```
+
+#### Deleting Immediately
+
+It's possible to delete a source file from the file system immediately by calling one of the following methods:
+
+```ts
+await sourceFile.deleteImmediately();
+sourceFile.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.
+
+### Copy
+
+Copy a source file to a new file by specifying a new relative or absolute path:
+
+```ts setup: const someDirectoryObject: Directory
+const newSourceFile = sourceFile.copy("newFileName.ts");
+// this won't throw if a file exists at the specified path
+const otherSourceFile = sourceFile.copy("other.ts", { overwrite: true });
+// or specify directory to copy to
+sourceFile.copyToDirectory("/some/dir");
+sourceFile.copyToDirectory(someDirectoryObject);
+```
+
+Note: If necessary, this will automatically update the module specifiers of the relative import and export declarations
+in the copied file.
+
+#### Copying Immediately
+
+As with `.deleteImmediately()` it's possible to immediately copy a file and have the changes reflected on the file system:
+
+```ts
+await sourceFile.copyImmediately("NewFile.ts");
+sourceFile.copyImmediatelySync("NewFile2.ts");
+```
+
+### Move
+
+Moves a source file to a new file by specifying a new relative or absolute path:
+
+```ts setup: const someDirectoryObject: Directory
+sourceFile.move("newFileName.ts");
+// this won't throw if a file exists at the specified path
+sourceFile.move("other.ts", { overwrite: true });
+// or specify directory to move to
+sourceFile.moveToDirectory("/some/dir");
+sourceFile.moveToDirectory(someDirectoryObject);
+```
+
+Note: If necessary, this will automatically update the module specifiers of the relative import and export declarations
+in the moving file and the relative import and export declarations in other files to point to the new location.
+
+#### Moving Immediately
+
+As with `.deleteImmediately()` it's possible to immediately move a file and have the changes reflected on the file system:
+
+```ts
+await sourceFile.moveImmediately("NewFile.ts");
+sourceFile.moveImmediatelySync("NewFile2.ts");
+```
+
+### Refresh from file system
+
+Refresh the source file from the file system:
+
+```ts
+import { FileSystemRefreshResult } from "ts-morph";
+
+// returns: FileSystemRefreshResult (NoChange, Updated, Deleted)
+const result = await sourceFile.refreshFromFileSystem(); // or refreshFromFileSystemSync()
+```
+
+This is useful when you are using a file system watcher and want to refresh a source file from the file system based on changes.
+
+If the file was _updated_: All the child nodes of the source file will be forgotten and you will have to renavigate the file.
+If the file was _deleted_: The source file will be removed and all its nodes forgotten.
+
+### Remove
+
+Remove a source file from the project by calling:
+
+```ts
+sourceFile.forget();
+```
+
+Or alternatively:
+
+```ts
+project.removeSourceFile(sourceFile); // returns: boolean (true if was removed)
+```
+
+Note: This does not delete the file from the file system. To do delete it, call `#delete()`.
+
+### Reference comments
+
+```ts
+// gets `/// <reference path="..." />` comments
+const pathReferenceDirectives = sourceFile.getPathReferenceDirectives();
+// gets `/// <reference types="..." />` comments
+const typeReferenceDirectives = sourceFile.getTypeReferenceDirectives();
+// gets `/// <reference lib="..." />` comments
+const libReferenceDirectives = sourceFile.getLibReferenceDirectives();
+```
+
+### Import Declarations
+
+See [Import Declarations](imports).
+
+### Export Declarations
+
+See [Export Declarations](exports).
+
+### Indenting / Unindenting
+
+Call the `.indent` or `.unindent` methods.
+
+<!-- dprint-ignore -->
+```ts
+sourceFile.indent(5);        // indent line containing position 5
+sourceFile.indent([5, 10]);  // indent line or lines within position range [5-10]
+sourceFile.indent(10, 3);    // indent line containing position 10, 3 times
+
+sourceFile.unindent(10);     // unindent line containing position 10
+
+sourceFile.indent(10, -1);   // unindent line containing position 10 (specify negative times)
+sourceFile.unindent(10, -1); // indent line containing position 10 (specify negative times)
+```
+
+This will indent and unindent based on your [manipulation settings](../manipulation/settings).
+
+### Getting referencing files
+
+Getting the source files that reference this source file in nodes like import declarations, export declarations, import equals declarations, and dynamic imports can be found by using the following:
+
+```ts
+const referencingSourceFiles = sourceFile.getReferencingSourceFiles();
+```
+
+To get the nodes that reference the source file in other source files:
+
+```ts
+const referencingNodes = sourceFile.getReferencingNodesInOtherSourceFiles();
+```
+
+To get the string literals that reference this source file in other source files:
+
+```ts
+const referencingLiterals = sourceFile.getReferencingLiteralsInOtherSourceFiles();
+```
+
+### Getting referenced files
+
+The opposite of the referencing files, is the referenced files—files that are referenced in nodes within the current file.
+
+```ts
+const referencedSourceFiles = sourceFile.getReferencedSourceFiles();
+```
+
+To get the nodes that reference other source files:
+
+```ts
+const nodesReferencingOtherSourceFiles = sourceFile.getNodesReferencingOtherSourceFiles();
+```
+
+To get the string literals that reference other source files:
+
+```ts
+const literalsReferencingOtherSourceFiles = sourceFile.getLiteralsReferencingOtherSourceFiles();
+// or to get all the literals that reference a module (and may not have been resolved to a source file)
+const importLiterals = sourceFile.getImportStringLiterals();
+```
+
+### Relative File Paths
+
+It might be useful to get the relative path from one source file to another source file or directory.
+
+```ts setup: let sourceFileFrom: SourceFile, sourceFileTo: SourceFile;
+const relativePath = sourceFileFrom.getRelativePathTo(sourceFileTo);
+```
+
+Or to get the module specifier text from one source file to another source file or directory.
+
+```ts setup: let sourceFileFrom: SourceFile, sourceFileTo: SourceFile;
+const moduleSpecifier = sourceFileFrom.getRelativePathAsModuleSpecifierTo(sourceFileTo);
+```
+
+## Source File Code Fixes
+
+### Organizing Imports
+
+It's possible to organize all the imports in a source file via the ["organize imports"](https://blogs.msdn.microsoft.com/typescript/2018/03/27/announcing-typescript-2-8/)
+feature from TypeScript 2.8.
+
+```ts
+sourceFile.organizeImports();
+```
+
+Note: This will forget all the previously navigated nodes so it's recommended to make this either the first or last action you do to a source file.
+
+### Add Missing Imports
+
+To add all the missing import declarations to a source file, use the following method:
+
+```ts
+sourceFile.fixMissingImports();
+```
+
+### Fix Unused Identifiers
+
+To remove all unused declarations (ex. variables, classes, etc..) from a source file, use the following method:
+
+```ts
+sourceFile.fixUnusedIdentifiers();
+```
+
+Tip: For optimal results, sometimes this method needs to be called more than once. There could be nodes that are only referenced in unused declarations and in this case another call would remove them.
+
+Note: This will forget all the previously navigated nodes so it's recommended to make this either the first or last action you do to a source file.

package/vendor/ts-morph/docs/details/type-aliases.md

@@ -0,0 +1,34 @@
+---
+title: Type Aliases
+---
+
+## Type Aliases
+
+Type aliases can be retrieved from source files, namespaces, or function bodies:
+
+```ts
+const typeAliases = sourceFile.getTypeAliases();
+const typeAlias = sourceFile.getTypeAlias("TypeAlias");
+const firstExportedTypeAlias = sourceFile.getTypeAlias(a => a.hasExportKeyword());
+```
+
+Most of the information you can get about type aliases is covered in other sections.
+
+### Add/Insert
+
+Add or insert type aliases to a source file, namespace, or function like declarations by calling `addTypeAlias()`, `addTypeAliases()`, `insertTypeAlias()`, or `insertTypeAliases()`.
+
+```ts
+const typeAliasDeclaration = sourceFile.addTypeAlias({
+  name: "TypeAliasName",
+  type: "string",
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+typeAliasDeclaration.remove();
+```

package/vendor/ts-morph/docs/details/type-parameters.md

@@ -0,0 +1,72 @@
+---
+title: Type Parameters
+---
+
+## Type Parameters
+
+Type parameters can be retreived from nodes by calling `getTypeParameters()`:
+
+```ts
+const typeParameters = classDeclaration.getTypeParameters();
+```
+
+### Inserting/Adding
+
+Insert or add type parameters by calling `insertTypeParameter()`, `insertTypeParameters()`, `addTypeParameter()`, or `addTypeParameters()`.
+
+For example:
+
+```ts
+const typeParameter = classDeclaration.insertTypeParameter(1, {
+  name: "T",
+  constraint: "string", // optional
+});
+```
+
+### Removing
+
+Remove a type parameter by calling `.remove()` on it:
+
+```ts
+typeParameter.remove();
+```
+
+### Constraint
+
+Get the constraint type node:
+
+```ts
+const constraint = typeParameter.getConstraint(); // returns: TypeNode | undefined
+```
+
+Or set the constraint:
+
+```ts
+typeParameter.setConstraint("string");
+```
+
+Or remove it:
+
+```ts
+typeParameter.removeConstraint();
+```
+
+### Default
+
+Get the default type node:
+
+```ts
+const defaultNode = typeParameter.getDefault(); // returns: TypeNode | undefined
+```
+
+Or set the default type node:
+
+```ts
+typeParameter.setDefault("string");
+```
+
+Or remove it:
+
+```ts
+typeParameter.removeDefault();
+```