fcis 0.1.0

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

@@ -0,0 +1,117 @@
+---
+title: Enums
+---
+
+## Enums
+
+Enums can be retrieved from source files, namespaces, or function bodies:
+
+```ts
+const enums = sourceFile.getEnums();
+const enum1 = sourceFile.getEnum("Enum1");
+const enum2 = sourceFile.getEnum(e => e.getMembers().length === 5);
+```
+
+### Add/Insert
+
+Add or insert enums to a source file, namespace, or function like declarations by calling `addEnum()`, `addEnums()`, `insertEnum()`, or `insertEnums()`.
+
+```ts
+const enumDeclaration = sourceFile.addEnum({
+  name: "EnumName",
+  members: [{
+    name: "member",
+  }],
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+enumDeclaration.remove();
+```
+
+### Get all members
+
+Use `getMembers()`:
+
+```ts
+const members = enumDeclaration.getMembers();
+```
+
+### Get member
+
+Use `getMember()`:
+
+```ts
+const member1 = enumDeclaration.getMember("member1");
+const member2 = enumDeclaration.getMember(m => m.getValue() === 1);
+```
+
+### Add/Insert member
+
+Members can be added by calling `addMember()`, `addMembers()`, `insertMember()`, or `insertMembers()`:
+
+```ts
+const member = enumDeclaration.addMember({
+  name: "newMember",
+  value: 10,
+});
+```
+
+### Const enum
+
+Check if it's a const enum via `isConstEnum()`:
+
+```ts
+enumDeclaration.isConstEnum(); // returns: boolean
+```
+
+Get the `const` keyword via `getConstKeyword()`:
+
+```ts
+enumDeclaration.getConstKeyword(); // returns: Node | undefined
+```
+
+Set if it's a const enum via `setIsConstEnum(value)`:
+
+```ts
+enumDeclaration.setIsConstEnum(true);
+enumDeclaration.setIsConstEnum(false);
+```
+
+## Enum Members
+
+```ts
+const member = enumDeclaration.getMember("member");
+```
+
+### Value
+
+The value can be retrieved whether it is implicitly or explicitly defined:
+
+```ts
+enumMember.getValue(); // returns: string | number
+```
+
+It can also be set to a number:
+
+```ts
+enumMember.setValue(5);
+```
+
+Or a string:
+
+```ts
+enumMember.setValue("string value");
+```
+
+### Removing
+
+Call `remove()` on it:
+
+```ts
+enumMember.remove();
+```

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

@@ -0,0 +1,308 @@
+---
+title: Export
+---
+
+## Export
+
+Certain nodes in TypeScript can be [exported](https://www.typescriptlang.org/docs/handbook/modules.html).
+
+### Is export
+
+Use `isExported()`, `isNamedExport()`, or `isDefaultExport()` methods:
+
+```ts
+functionDeclaration.isExported(); // returns: boolean
+functionDeclaration.isNamedExport(); // returns: boolean
+functionDeclaration.isDefaultExport(); // returns: boolean
+```
+
+### `export` and `default` keyword
+
+Use the `has` methods to check for the `export` and `default` keywords:
+
+```ts
+functionDeclaration.hasExportKeyword(); // returns: boolean
+functionDeclaration.hasDefaultKeyword(); // returns: boolean
+```
+
+And use the `get` methods to get the keywords:
+
+```ts
+functionDeclaration.getExportKeyword();
+functionDeclaration.getDefaultKeyword();
+```
+
+### Setting as default export
+
+Use `setIsDefaultExport` to set a node as being a default export or not:
+
+```ts
+functionDeclaration.setIsDefaultExport(true); // be one
+functionDeclaration.setIsDefaultExport(false); // don't be one
+```
+
+Note: This will throw an exception if the node's parent is not a source file.
+
+### Setting as export
+
+Use `setIsExported` to set a node as being a named export if the parent is a source file or an export of a namespace if the parent is a namespace:
+
+```ts
+functionDeclaration.setIsExported(true); // be one
+functionDeclaration.setIsExported(false); // don't be one
+```
+
+### Get default export symbol
+
+If it exists, the default export symbol can be retrieved from source file or module:
+
+```ts
+const defaultExportSymbol = sourceFile.getDefaultExportSymbol(); // returns: Symbol | undefined
+```
+
+### Remove default export
+
+Use:
+
+```ts
+sourceFile.removeDefaultExport();
+```
+
+Note: This is safe to call even when there is no default export.
+
+### Getting Exported Declarations
+
+The exported declarations of a file or module can be retrieved via `.getExportedDeclarations()`. This will return a map keyed on the export name with a value of the exported declarations for that name.
+
+For example, given the following setup:
+
+<!-- dprint-ignore -->
+```ts
+// main.ts
+export * from "./classes";
+export { Interface1 as AliasedInterface } from "./interfaces";
+
+namespace MergedNamespace { let t; }
+namespace MergedNamespace { let u; }
+
+export { MergedNamespace };
+
+export default 5;
+
+// classes.ts
+export * from "./Class1";
+export * from "./Class2";
+
+// Class1.ts
+export class Class1 {}
+
+// Class2.ts
+export class Class2 {}
+
+// interfaces.ts
+export interface Interface1 {}
+export interface Interface2 {}
+```
+
+The following code:
+
+```ts
+import { ExportedDeclarations, Project } from "ts-morph";
+
+const project = new Project();
+project.addSourceFilesAtPaths("**/*.ts");
+const mainFile = project.getSourceFileOrThrow("main.ts");
+
+for (const [name, declarations] of mainFile.getExportedDeclarations())
+  console.log(`${name}: ${declarations.map(d => d.getText()).join(", ")}`);
+```
+
+Outputs the following:
+
+```
+Class1: export class Class1 {}
+Class2: export class Class2 {}
+AliasedInterface: export interface Interface1 {}
+MergedNamespace: namespace MergedNamespace { let t; }, namespace MergedNamespace { let u; }
+default: 5
+```
+
+## Export Declarations
+
+Export declarations look like this:
+
+```ts setup: class OtherClass {}
+export { MyClass } from "./other-file";
+export * from "./some-file";
+export { OtherClass };
+```
+
+Get the export declarations by calling:
+
+```ts
+const exportDeclarations = sourceFile.getExportDeclarations();
+// or to get the first one that matches a condition
+const exportDeclaration = sourceFile.getExportDeclaration(d => d.hasNamedExports());
+const exportDecForModule = sourceFile.getExportDeclaration("module-specifier-text");
+
+// tell if it has named exports
+exportDeclaration.hasNamedExports();
+// or if it's a namespace export
+exportDeclaration.isNamespaceExport();
+// get/set the module specifier
+exportDeclaration.getModuleSpecifier(); // returns: StringLiteral | undefined
+exportDeclaration.getModuleSpecifierValue(); // returns: string | undefined
+exportDeclaration.setModuleSpecifier("./new-file");
+exportDeclaration.setModuleSpecifier(sourceFile);
+exportDeclaration.removeModuleSpecifier();
+exportDeclaration.hasModuleSpecifier(); // returns: boolean
+exportDeclaration.isModuleSpecifierRelative(); // if the module specifier starts with ./ or ../
+exportDeclaration.getModuleSpecifierSourceFile(); // returns: SourceFile | undefined
+```
+
+### Add/Insert
+
+Add or insert use `insertExportDeclaration`, `insertExportDeclarations`, `addExportDeclaration`, or `addExportDeclarations`:
+
+```ts
+const exportDeclaration = sourceFile.addExportDeclaration({
+  namedExports: ["MyClass"],
+  moduleSpecifier: "./file",
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+exportDeclaration.remove();
+```
+
+### To Namespace Export
+
+Given an export declaration with named exports:
+
+```ts
+export { Export1, Export2, Export3 } from "./other-file";
+```
+
+Calling `exportDeclaration.toNamespaceExport();` will change the code to the following:
+
+```ts
+export * from "./other-file";
+```
+
+### Named Exports
+
+Get the named exports from an export declaration:
+
+```ts
+const namedExports = exportDeclaration.getNamedExports();
+```
+
+Adding or inserting named exports can be done via the `addNamedExport`, `addNamedExports`, `insertNamedExport`, or `insertNamedExports` methods.
+
+```ts
+const namedExport = exportDeclaration.addNamedExport({
+  name: "MyClass",
+  alias: "MyAliasName", // alias is optional
+});
+// or
+exportDeclaration.addNamedExport("MyClass");
+```
+
+Removing one named export:
+
+```ts
+namedExport.remove();
+```
+
+#### Export specifier
+
+Export specifiers are the individual named exports.
+
+##### Name
+
+```ts
+namedExport.getNameNode(); // returns: Identifier
+namedExport.setName("NewName");
+```
+
+##### Alias
+
+```ts
+namedExport.getAliasNode(); // returns: Identifier | undefined
+namedExport.setAlias("NewAliasName");
+namedExport.renameAlias("NewAliasName");
+```
+
+_Note:_ Renaming the alias will set or rename any uses of the alias or identifier to the new value.
+
+##### Local Target Declarations
+
+The local target declarations are the declarations that the export specifier is referencing:
+
+```ts
+const declarations = namedExport.getLocalTargetDeclarations(); // returns: Node[]
+```
+
+##### Parent export declaration
+
+```ts
+namedExport.getExportDeclaration(); // returns: ExportDeclaration
+```
+
+## Export Assignments
+
+Export assignments look like the following:
+
+```ts setup: let name: string;
+export = 5;
+export default name;
+```
+
+Get the export assignments by calling:
+
+```ts
+const exportAssignments = sourceFile.getExportAssignments();
+// or to get the first one that matches a condition
+const exportAssignment = sourceFile.getExportAssignment(d => d.isExportEquals());
+
+// get if it's `export =` or `export default`
+const isExportEquals = exportAssignment.isExportEquals();
+// get the expression
+const expression = exportAssignment.getExpression();
+```
+
+Set whether one is an export equals or export default:
+
+```ts
+exportAssignment.setIsExportEquals(false); // sets to export default
+```
+
+Set its expression:
+
+```ts
+exportAssignment.setExpression(writer => writer.write("5"));
+exportAssignment.setExpression("6");
+```
+
+### Add/Insert
+
+Add or insert use `insertExportAssignment`, `insertExportAssignments`, `addExportAssignment`, or `addExportAssignments`:
+
+```ts
+const exportAssignment = sourceFile.addExportAssignment({
+  isExportEquals: true, // defaults to true
+  expression: "5",
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+exportAssignment.remove();
+```

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

@@ -0,0 +1,46 @@
+---
+title: Expressions
+---
+
+## Expression With Type Arguments
+
+These are found in certain areas. For example `extends` and `implements` expressions.
+
+### Getting expression
+
+```ts
+const expression = expressionWithTypeArgs.getExpression(); // returns: Node
+```
+
+### Getting type arguments
+
+```ts
+const typeArgs = expressionWithTypeArgs.getTypeArguments(); // returns: TypeNode[]
+```
+
+## Call Expressions
+
+Call expressions are statements that call a function:
+
+```ts setup: const doSomething: () => void;
+doSomething();
+```
+
+### Getting call signatures
+
+From a given node, get all the children or descendants that are call expressions.
+
+For example:
+
+```ts
+const childCallExpressions = node.getChildrenOfKind(SyntaxKind.CallExpression);
+const descendantCallExpressions = node.getDescendantsOfKind(SyntaxKind.CallExpression);
+```
+
+### Return type
+
+Use the following:
+
+```ts
+const returnType = callExpression.getReturnType();
+```

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

@@ -0,0 +1,150 @@
+---
+title: Functions
+---
+
+## Function Declarations
+
+Functions can be retrieved from source files, other namespaces, or function bodies:
+
+```ts
+const functions = sourceFile.getFunctions();
+const function1 = sourceFile.getFunction("Function1");
+const firstFunctionWithChildFunction = sourceFile.getFunction(f => f.getFunctions().length > 0);
+```
+
+Most of the information you can get about functions is covered in other sections.
+
+### Name
+
+It's important to note that function declarations may not have a name. For example:
+
+```ts
+export default function() {
+  // etc...
+}
+```
+
+For this reason, the methods like `.getName()` and `.getNameNode()` are nullable on `FunctionDeclaration`.
+
+### Add/Insert
+
+Add or insert functions to a source file, namespace, or function like declarations by calling `addFunction()`, `addFunctions()`, `insertFunction()`, or `insertFunctions()`.
+
+```ts
+const functionDeclaration = sourceFile.addFunction({
+  name: "FunctionName",
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+functionDeclaration.remove();
+```
+
+### Overloads
+
+By default, in ambient contexts or for ambient nodes, all overloads will be returned. In non-ambient contexts, only the implementation will be returned.
+
+Get the overloads by calling:
+
+```ts
+const overloads = functionDeclaration.getOverloads(); // returns: FunctionDeclaration[]
+```
+
+Or tell if the current declaration is an overload by calling either:
+
+```ts
+functionDeclaration.isOverload();
+functionDeclaration.isImplementation();
+```
+
+From the overloads, get the implementation by calling:
+
+```ts
+const implementation = functionOverload.getImplementation();
+```
+
+#### Add/Insert
+
+Add or insert overloads by using either the `.addOverload()`, `.addOverloads()`, `.insertOverload()`, or `insertOverloads()` methods.
+
+#### Remove
+
+Call `.remove()` on the overload:
+
+```ts
+functionOverload.remove();
+```
+
+### Set body text
+
+The body text can be set via the `.setBodyText()` method:
+
+```ts
+functionDeclaration.setBodyText("const myNumber = 5;");
+```
+
+Or alternatively, write the body text with [code-block-writer](https://github.com/dsherret/code-block-writer):
+
+```ts
+functionDeclaration.setBodyText(writer =>
+  writer.writeLine("const myNumber = 5;")
+    .write("if (myNumber === 5)").block(() => {
+      writer.writeLine("console.log('yes')");
+    })
+);
+```
+
+Using the writer is very useful because it will write code out using the indentation and newline settings of the AST. It's also easier to use.
+
+### Get body text
+
+This returns the body text without leading indentation or leading and trailing whitespace.
+
+```ts
+console.log(functionDeclaration.getBodyText());
+```
+
+### Unwrap
+
+A function declaration can be replaced with its body using the `.unwrap()` method.
+
+Given the following code:
+
+```ts
+function someFunction() {
+  function innerFunction() {
+  }
+
+  const someDeclaration = 5;
+}
+```
+
+Calling `.unwrap()` on the function will change the code to the following:
+
+```ts
+function innerFunction() {
+}
+
+const someDeclaration = 5;
+```
+
+## Function Expressions
+
+They exist in an expression:
+
+```ts
+const add = function(a: number, b: number) {
+  return a + b;
+};
+```
+
+In this case, it can be retrieved via the variable declaration's [initializer](initializers).
+
+```ts
+const functionExpression = sourceFile.getVariableDeclarationOrThrow("add")
+  .getInitializerIfKindOrThrow(SyntaxKind.FunctionExpression);
+```

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

@@ -0,0 +1,27 @@
+---
+title: Generators
+---
+
+## Generators
+
+Nodes like `FunctionDeclaration` and `MethodDeclaration` can be generators.
+
+### Tell if a generator
+
+```ts
+functionDeclaration.isGenerator(); // returns: boolean
+```
+
+### Set as a generator
+
+```ts
+functionDeclaration.setIsGenerator(true); // or false to set as not one
+```
+
+### Get asterisk token (`*`)
+
+Gets the asterisk token or undefined if not exists:
+
+```ts
+functionDeclaration.getAsteriskToken();
+```

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

@@ -0,0 +1,79 @@
+---
+title: Identifiers
+---
+
+## Identifiers
+
+Identifiers are nodes that reference or define the name of a node.
+
+For example, in the following code the identifiers are the variable name and the use of the variable:
+
+```ts
+const identifier = 5;
+console.log(identifier);
+```
+
+### Getting identifiers
+
+A lot of the time, a node will have a name and you can retrieve the identifier via `.getNameNode()`.
+
+If not, from a given node, you can get all the children or descendants that are identifiers. For example:
+
+```ts
+const childIdentifiers = node.getChildrenOfKind(SyntaxKind.Identifier);
+const descendantIdentifiers = node.getDescendantsOfKind(SyntaxKind.Identifier);
+```
+
+### Text
+
+Get the text:
+
+```ts
+const text = identifier.getText();
+```
+
+### Rename
+
+Rename an identifier:
+
+```ts
+identifier.rename("someNewName");
+```
+
+### Find References
+
+Find all the references:
+
+```ts
+const references = identifier.findReferences();
+```
+
+### Get Definitions
+
+Gets the definitions of the identifier. This is similar to "go to definition" functionality that exists with TypeScript in most IDEs.
+
+```ts
+const definitions = identifier.getDefinitions();
+```
+
+Or just get the nodes:
+
+```ts
+const nodes = identifier.getDefinitionNodes();
+```
+
+### Get Implementations
+
+Gets the implementations of the identifier. This is similar to "go to implementation" functionality that exists with TypeScript in most IDEs.
+
+```ts
+const implementations = identifier.getImplementations();
+```
+
+### Type
+
+Get the type of an identifier:
+
+```ts
+const identifierType = identifier.getType();
+```