fcis 0.1.0

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

@@ -0,0 +1,191 @@
+---
+title: Imports
+---
+
+## Imports
+
+Imports of a source file or module can be retrieved by calling:
+
+```ts
+// get them all
+const imports = sourceFile.getImportDeclarations();
+// or get the first one that matches a condition
+const importWithDefaultImport = sourceFile.getImportDeclaration(i => i.getDefaultImport() != null);
+const someModuleImport = sourceFile.getImportDeclaration("module-specifier-text");
+```
+
+### Add/Insert
+
+Add or insert use `insertImportDeclaration`, `insertImportDeclarations`, `addImportDeclaration`, or `addImportDeclarations`:
+
+```ts
+const importDeclaration = sourceFile.addImportDeclaration({
+  defaultImport: "MyClass",
+  moduleSpecifier: "./file",
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+importDeclaration.remove();
+```
+
+### Module specifier
+
+Get it:
+
+```ts
+const moduleSpecifier = importDeclaration.getModuleSpecifier(); // returns: StringLiteral
+```
+
+Or get it's value:
+
+```ts
+const moduleSpecifierValue = importDeclaration.getModuleSpecifierValue(); // returns: string
+```
+
+_Example:_ For `import settings from "./settings";` would return `./settings`.
+
+Set it:
+
+```ts
+importDeclaration.setModuleSpecifier("./new-file");
+// or set by source file
+importDeclaration.setModuleSpecifier(sourceFile);
+```
+
+Get the referenced source file:
+
+```ts
+const sourceFile = importDeclaration.getModuleSpecifierSourceFile(); // returns: SourceFile | undefined
+```
+
+Get if the module specifier is relative (starts with `./` or `../`):
+
+```ts
+importDeclaration.isModuleSpecifierRelative();
+```
+
+### Default import
+
+Get it:
+
+```ts
+const defaultImport = importDeclaration.getDefaultImport(); // returns: Identifier | undefined
+```
+
+Set it:
+
+```ts
+importDeclaration.setDefaultImport("MyClass");
+importDeclaration.renameDefaultImport("MyClass2");
+importDeclaration.removeDefaultImport();
+```
+
+#### Example
+
+Given the file:
+
+```ts
+import MyClass from "./file";
+
+const instance = new MyClass();
+```
+
+Doing the following:
+
+```ts
+const importDeclaration = sourceFile.getImportDeclarations()[0];
+importDeclaration.renameDefaultImport("NewName");
+```
+
+Will rename the default import and all its usages:
+
+```ts
+import NewName from "./file";
+
+const instance = new NewName();
+```
+
+### Namespace import
+
+Get it:
+
+```ts
+const namespaceImport = importDeclaration.getNamespaceImport(); // returns: Identifier | undefined
+```
+
+Set it:
+
+```ts
+importDeclaration.setNamespaceImport("newName");
+```
+
+_Note:_ Setting the namespace import for an existing namespace import will rename any uses of the namespace import in the current file.
+
+Remove it:
+
+```ts
+importDeclaration.removeNamespaceImport();
+```
+
+### Named imports
+
+Getting a named import:
+
+```ts
+const namedImports = importDeclaration.getNamedImports(); // returns: ImportSpecifier
+```
+
+Adding or inserting named imports can be done via the `addNamedImport`, `addNamedImports`, `insertNamedImport`, or `insertNamedImports` methods.
+
+```ts
+const namedImport = importDeclaration.addNamedImport({
+  name: "MyClass",
+  alias: "MyAliasName", // alias is optional
+});
+// or
+importDeclaration.addNamedImports(["MyClass", "SomeInterface"]);
+```
+
+Removing one named import:
+
+```ts
+namedImport.remove();
+```
+
+Removing all named imports:
+
+```ts
+importDeclaration.removeNamedImports();
+```
+
+#### Import specifier
+
+Import specifiers are the individual named imports.
+
+##### Name
+
+```ts
+namedImport.getNameNode(); // returns: Identifier
+namedImport.setName("NewName");
+```
+
+##### Alias
+
+```ts
+namedImport.getAliasNode(); // returns: Identifier | undefined
+namedImport.setAlias("NewAliasName");
+namedImport.renameAlias("NewAliasName");
+```
+
+_Note:_ Renaming the alias will set or rename any uses of the alias or identifier in the current file to the new value.
+
+##### Parent import declaration
+
+```ts
+namedImport.getImportDeclaration(); // returns: ImportDeclaration
+```

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

@@ -0,0 +1,52 @@
+---
+title: Details
+---
+
+## Details
+
+There is navigation support for most parts of the language at the current moment, but not everything.
+
+Manipulation support is lacking.
+
+Find out more information about:
+
+- [Source Files](source-files)
+- [Classes](classes)
+- [Decorators](decorators)
+- [Enums](enums)
+- [Functions](functions)
+- [Imports](imports)
+- [Interfaces](interfaces)
+- [Modules](modules)
+- [Parameters](parameters)
+- [Type Parameters](type-parameters)
+- [Type Aliases](type-aliases)
+- [Variables](variables)
+- Type parameters - todo
+- Symbols - todo
+
+Types:
+
+- [Types](types)
+- [Signatures](signatures)
+- Type Nodes - todo
+
+Common:
+
+- [Expressions](expressions)
+- [Object Literal Expressions](object-literal-expressions)
+- [Identifiers](identifiers)
+- [Ambient](ambient)
+- [Async](async)
+- [Exports](exports)
+- [Generators](generators)
+- [Initializers](initializers)
+- [JS Docs](documentation)
+- [Literals](literals)
+- [Modifiers](modifiers)
+- [Comments](comments)
+- Question tokenable - todo
+- Readonly - todo
+- Return Types - todo
+- Scope - todo
+- Static - todo

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

@@ -0,0 +1,40 @@
+---
+title: Initializers
+---
+
+## Initializers
+
+### Getting
+
+For example, given the following code:
+
+```ts
+const add = function(a: number, b: number) {
+  return a + b;
+};
+```
+
+The initializer can be retrieved in any of these ways:
+
+```ts
+variableDeclaration.getInitializer(); // returns: Expression | undefined
+variableDeclaration.getInitializerOrThrow(); // returns: Expression
+variableDeclaration.getInitializerIfKind(SyntaxKind.FunctionExpression); // returns: Expression | undefined
+variableDeclaration.getInitializerIfKindOrThrow(SyntaxKind.FunctionExpression); // returns: Expression
+```
+
+### Removing
+
+Use `.removeInitializer()` on the parent node. For example:
+
+```ts
+variableDeclaration.removeInitializer();
+```
+
+### Setting
+
+Use `.setInitializer(...)`:
+
+```ts
+variableDeclaration.setInitializer("2 + 2");
+```

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

@@ -0,0 +1,218 @@
+---
+title: Interfaces
+---
+
+## Interface Declarations
+
+Interface declarations can be retrieved from source files, namespaces, or function bodies:
+
+```ts
+const interfaces = sourceFile.getInterfaces();
+const interface1 = sourceFile.getInterface("Interface1");
+const firstInterfaceWith5Properties = sourceFile.getInterface(i => i.getProperties().length === 5);
+```
+
+### Add/Insert
+
+Add or insert interfaces to a source file, namespace, or function like declarations by calling `addInterface()`, `addInterfaces()`, `insertInterface()`, or `insertInterfaces()`.
+
+```ts
+const interfaceDeclaration = sourceFile.addInterface({
+  name: "InterfaceName",
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+interfaceDeclaration.remove();
+```
+
+### Extends expressions
+
+Will return [`ExpressionWithTypeArguments[]`](expressions):
+
+```ts
+const extendsExpressions = interfaceDeclaration.getExtends();
+```
+
+Add or insert extends expressions:
+
+```ts
+interfaceDeclaration.addExtends("Named");
+interfaceDeclaration.addExtends(["Named", "Aged"]);
+interfaceDeclaration.insertExtends(1, "Named");
+interfaceDeclaration.insertExtends(2, ["Named", "Aged"]);
+```
+
+Remove an expression:
+
+```ts
+interfaceDeclaration.removeExtends(0); // index
+interfaceDeclaration.removeExtends(interfaceDeclaration.getExtends()[0]); // node
+```
+
+### Members
+
+Get all the members of the interface:
+
+```ts
+const members = interfaceDeclaration.getMembers();
+```
+
+### Construct signatures
+
+Use:
+
+```ts
+const constructSignatures = interfaceDeclaration.getConstructSignatures();
+const constructSignature = interfaceDeclaration.getConstructSignature(c => c.getParameters().length > 2);
+```
+
+#### Add/Insert
+
+To add or insert use `addConstructSignature()`, `addConstructSignatures()`, `insertConstructSignature`, or `insertConstructSignatures()`:
+
+```ts
+const constructSignature = interfaceDeclaration.addConstructSignature({ returnType: "SomeClass" });
+```
+
+#### Remove
+
+Remove a construct signature:
+
+```ts
+constructSignature.remove();
+```
+
+### Call signatures
+
+Use:
+
+```ts
+const callSignatures = interfaceDeclaration.getCallSignatures();
+const callSignature = interfaceDeclaration.getCallSignature(c => c.getParameters().length > 2);
+```
+
+#### Add/Insert
+
+To add or insert use `addCallSignature()`, `addCallSignatures()`, `insertCallSignature`, or `insertCallSignatures()`:
+
+```ts
+const callSignature = interfaceDeclaration.addCallSignature({ returnType: "SomeClass" });
+```
+
+#### Remove
+
+Remove a call signature:
+
+```ts
+callSignature.remove();
+```
+
+### Index signatures
+
+Use:
+
+```ts
+const indexSignatures = interfaceDeclaration.getIndexSignatures();
+const indexSignature = interfaceDeclaration.getIndexSignature(s => s.getKeyName() === "keyName");
+```
+
+#### Add/Insert
+
+To add or insert use `addIndexSignature()`, `addIndexSignatures()`, `insertIndexSignature`, or `insertIndexSignatures()`:
+
+```ts
+const indexSignature = interfaceDeclaration.addIndexSignature({
+  keyName: "someKey", // defaults to key
+  keyType: "string", // defaults to string
+  returnType: "SomeClass",
+});
+```
+
+#### Remove
+
+Remove an index signature:
+
+```ts
+indexSignature.remove();
+```
+
+### Method signatures
+
+Use:
+
+```ts
+const methodSignatures = interfaceDeclaration.getMethods();
+const myMethod = interfaceDeclaration.getMethod("myMethod");
+const firstMethodWith4Params = interfaceDeclaration.getMethod(m => m.getParameters().length === 4);
+```
+
+#### Add/Insert
+
+To add or insert use `addMethod()`, `addMethods()`, `insertMethod`, or `insertMethods()`:
+
+```ts
+const methodSignature = interfaceDeclaration.insertMethod(1, { name: "newMethod", returnType: "boolean" });
+```
+
+#### Remove
+
+Remove a method signature:
+
+```ts
+methodSignature.remove();
+```
+
+### Properties
+
+Use:
+
+```ts
+const properties = interfaceDeclaration.getProperties();
+const myProperty = interfaceDeclaration.getProperty("myProperty");
+const firstStringProperty = interfaceDeclaration.getProperty(p => p.getType().getText() === "string");
+```
+
+#### Add/Insert
+
+To add or insert use `addProperty()`, `addProperties()`, `insertProperty`, or `insertProperties()`:
+
+```ts
+const propertySignature = interfaceDeclaration.insertProperty(1, { name: "newProperty", type: "string" });
+```
+
+#### Remove
+
+Remove a property signature:
+
+```ts
+propertySignature.remove();
+```
+
+### Base Types
+
+```ts
+const baseTypes = interfaceDeclaration.getBaseTypes();
+```
+
+### Base Declarations
+
+Gets the base interface, type alias, or class declarations:
+
+```ts
+const baseDeclarations = interfaceDeclaration.getBaseDeclarations();
+```
+
+### Implementations
+
+Get the implementations.
+
+```ts
+const implementations = interfaceDeclaration.getImplementations();
+```
+
+Similar to "go to implementation" command available in IDEs.

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

@@ -0,0 +1,20 @@
+---
+title: Literals
+---
+
+## Literals
+
+Literals:
+
+- `StringLiteral` (ex. `"some string"`)
+- `NumericLiteral` (ex. `5`, `10.53`)
+- `TrueLiteral` / `FalseLiteral` (ex. `true` / `false`)
+- `NoSubstitutionTemplateLiteral` (ex. `` `some string` ``)
+- `RegularExpressionLiteral` (ex. `/pattern/gi`)
+
+Methods:
+
+- `.getLiteralValue()` - Returns the string, number, boolean, or RegExp value.
+- `.setLiteralValue(...)` - Allows setting the literal value.
+- `isTerminated()` - If the literal is terminated.
+- `hasExtendedUnicodeEscape()` - If the literal has a unicode escape (ex. `\u{20bb7}`)

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

@@ -0,0 +1,38 @@
+---
+title: Modifiers
+---
+
+## Modifiers
+
+Modifiers are nodes that modify other nodes. For example, the `private` keyword is a modifier that changes the scope of a method on a class.
+
+Only certain nodes can have modifiers and they will have these functions.
+
+### Getting all modifiers
+
+```ts
+functionDeclaration.getModifiers();
+```
+
+### Getting first modifier by syntax kind
+
+Use `getFirstModifierByKind(syntaxKind: SyntaxKind);`.
+
+```ts
+functionDeclaration.getFirstModifierByKind(SyntaxKind.AsyncKeyword);
+```
+
+### Telling if has a modifier
+
+```ts
+functionDeclaration.hasModifier(SyntaxKind.AsyncKeyword); // returns: boolean
+```
+
+### Toggle modifier
+
+Toggles a modifier on or off:
+
+```ts
+functionDeclaration.toggleModifier("async");
+functionDeclaration.toggleModifier("async", false); // or explicit toggle
+```

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

@@ -0,0 +1,113 @@
+---
+title: Module / Namespace Declarations
+---
+
+## Module / Namespace Declarations
+
+Module declarations may look like any of the following:
+
+```ts ignore-error: 2664
+namespace MyNamespace {
+}
+
+module MyModule {
+}
+
+declare module "some-module" {
+}
+
+declare module "other-module";
+```
+
+They can be retrieved from source files or other modules/namespaces:
+
+```ts
+const modules = sourceFile.getModules();
+const namespace1 = sourceFile.getModule("Namespace1");
+const firstNamespaceWithClass = sourceFile.getModule(n => n.getClasses().length > 0);
+```
+
+Most of the information you can get about namespaces is covered in other sections.
+
+Note: Although it's a compile error, you can also retrieve namespaces from function bodies.
+
+### Add/Insert
+
+Add or insert namespaces to a source file, namespace, or function like declarations by calling `addModule()`, `addModules()`, `insertModule()`, or `insertModules()`.
+
+```ts
+const moduleDeclaration = sourceFile.addModule({
+  name: "ModuleName",
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+moduleDeclaration.remove();
+```
+
+### Module, namespace, or `global`?
+
+Check for the declaration kind or keywords:
+
+```ts
+moduleDeclaration.getDeclarationKind(); // returns: ModuleDeclarationKind
+// or
+moduleDeclaration.hasModuleKeyword(); // returns: boolean
+moduleDeclaration.hasNamespaceKeyword(); // returns: boolean
+```
+
+Or set the declaration kind:
+
+```ts
+moduleDeclaration.setDeclarationKind(ModuleDeclarationKind.Namespace);
+moduleDeclaration.setDeclarationKind(ModuleDeclarationKind.Module);
+moduleDeclaration.setDeclarationKind(ModuleDeclarationKind.Global);
+```
+
+Or get the keyword:
+
+```ts
+// returns: the module or namespace keyword or undefined if global
+moduleDeclaration.getDeclarationKindKeyword();
+```
+
+**Reminder:** Module declarations that are `global` have the following syntax:
+
+```ts ignore-error: 2664, 2669
+declare module "my-library" {
+  // this is a global namespace declaration
+  global {
+    const foo: string;
+  }
+}
+```
+
+### Unwrap
+
+A module declaration can be replaced with its body using the `.unwrap()` method.
+
+Given the following code:
+
+```ts
+namespace MyNamespace {
+  function someFunction() {
+  }
+
+  class SomeClass {
+  }
+}
+```
+
+Calling `.unwrap()` will change the code to the following:
+
+```ts
+function someFunction() {
+}
+
+class SomeClass {
+}
+```

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

@@ -0,0 +1,7 @@
+---
+title: Namespaces
+---
+
+## Namespaces
+
+See [Modules](modules).