fcis 0.1.0

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

@@ -0,0 +1,254 @@
+---
+title: Types
+---
+
+## Types
+
+Types are accessed by calling `.getType()` on nodes that are typed. For example:
+
+```ts
+const type = parameter.getType();
+```
+
+There are other ways for accessing a type. For example:
+
+```ts
+const returnType = functionDeclaration.getReturnType();
+```
+
+### Checking type is assignable to another type
+
+Note: Requires ts-morph 22+
+
+To check if a type is assignable to another type, use the `isAssignableTo` method:
+
+```ts
+if (stringLitType.isAssignableTo(stringType)) {
+  // ...
+}
+```
+
+### Compiler Type
+
+The underlying compiler type can be accessed via:
+
+```ts
+const compilerType = type.compilerType;
+```
+
+### Apparent type
+
+Given the following variable declaration:
+
+```ts
+const myVar = 4;
+```
+
+The type is `4` and the apparent type is `Number`.
+
+Retrieve the apparent type via the following:
+
+```ts
+const apparentType = type.getApparentType();
+```
+
+### Text
+
+Getting the type text can be achieved by calling `.getText()`:
+
+```ts
+const text = type.getText();
+```
+
+Sometimes this may not be good enough. If not, try to provide the enclosing node:
+
+```ts
+const text = type.getText(parameter);
+```
+
+Format it by providing `TypeFormatFlags`:
+
+```ts
+const text = type.getText(parameter, TypeFormatFlags.NoTruncation | TypeFormatFlags.WriteArrayAsGenericType);
+```
+
+Look at the declaration file for more available options for `TypeFormatFlags`.
+
+### Constraint and Default
+
+```ts
+const constraintType = type.getConstraint();
+const defaultType = type.getDefault();
+```
+
+### Intersection types
+
+```ts
+const intersectionTypes = type.getIntersectionTypes();
+```
+
+### Union types
+
+```ts
+const unionTypes = type.getUnionTypes();
+```
+
+### Properties
+
+Get the properties or property of a type:
+
+```ts
+const properties = type.getProperties();
+const prop1 = type.getProperty("prop1");
+const prop2 = type.getProperty(p => p.getName() === "prop2");
+```
+
+Or the apparent properties:
+
+```ts
+const apparentProperties = type.getApparentProperties();
+const prop1 = type.getApparentProperty("prop1");
+const prop2 = type.getApparentProperty(p => p.getName() === "prop2");
+```
+
+### Base types
+
+```ts
+const baseTypes = type.getBaseTypes();
+```
+
+### Base type of a literal type
+
+```ts setup: let numberLiteralType: Type;
+const numberType = numberLiteralType.getBaseTypeOfLiteralType();
+```
+
+### Call signatures
+
+```ts
+const callSignatures = type.getCallSignatures();
+```
+
+### Construct signatures
+
+Get the construct signatures (new signatures) of a type:
+
+```ts
+const constructSignatures = type.getConstructSignatures();
+```
+
+### Index types
+
+Get either the string index type (ex. for `{ [index: string]: Date; }` it would be `Date`)
+or the number index type (ex. for `{ [index: number]: object; }` it would be `object`):
+
+```ts
+const stringIndexType = type.getStringIndexType();
+const numberIndexType = type.getNumberIndexType();
+```
+
+### Tuple element types
+
+```ts
+const tupleElements = type.getTupleElements();
+```
+
+For example, for the type `[string, number]`, the above would return an array containing the type for `string` and `number`.
+
+### Non-nullable type
+
+Gets the non-nullable type from a nullable type:
+
+```ts
+const nonNullableType = type.getNonNullableType();
+```
+
+For example, `string | undefined` would return `string`.
+
+### Type flags
+
+This has information about the type, such as `TypeFlags.BooleanLike`.
+
+```ts
+const flags = type.getFlags();
+```
+
+Generally a method that starts with "is" exists on the type and you can easily use that instead of checking the flags (same with Object flags below).
+
+### Object flags
+
+This has information about object types, such as `ObjectFlags.Mapped`.
+
+```ts
+const objectFlags = type.getObjectFlags();
+```
+
+### Symbol
+
+Get the symbol of the type if it exists:
+
+```ts
+const typeSymbol = type.getSymbol();
+```
+
+### Alias symbol
+
+```ts
+const aliasSymbol = type.getAliasSymbol();
+```
+
+### Alias type arguments
+
+```ts
+const aliasTypeArgs = type.getAliasTypeArguments();
+```
+
+### Telling type
+
+Use any of the following methods:
+
+```ts
+type.isAnonymous();
+type.isAny();
+type.isArray();
+type.isBoolean();
+type.isBooleanLiteral();
+type.isClass();
+type.isClassOrInterface();
+type.isEnum();
+type.isEnumLiteral();
+type.isInterface();
+type.isIntersection();
+type.isLiteral();
+type.isNull();
+type.isNumber();
+type.isNumberLiteral();
+type.isObject();
+type.isString();
+type.isStringLiteral();
+type.isTemplateLiteral();
+type.isTuple();
+type.isUndefined();
+type.isUnion();
+type.isUnionOrIntersection();
+type.isUnknown();
+```
+
+If you see something that doesn't exist here and should (there's a lot missing), then please log an issue or submit a pull request.
+
+### Removing a Type
+
+Remove a type or a return type from a node:
+
+```ts
+propertyDeclaration.removeType();
+functionDeclaration.removeReturnType();
+```
+
+### TODO
+
+Not implemented. Getting...
+
+- Enum member types
+- Destructuring pattern
+- More...?

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

@@ -0,0 +1,110 @@
+---
+title: Variables
+---
+
+## Variable Statement
+
+A variable statement looks like the following:
+
+```ts
+export const var1 = "5", var2 = "6";
+```
+
+### Get a variable statement
+
+Can be retrieved from source files, namespaces, or function bodies:
+
+```ts
+const variableStatements = sourceFile.getVariableStatements();
+const firstExportedVariableStatement = sourceFile.getVariableStatement(s => s.hasExportKeyword());
+```
+
+### Add/Insert
+
+Add or insert variable statements to a source file, namespace, or function like declarations by calling `addVariableStatement()`, `addVariableStatements()`,
+`insertVariableStatement()`, or `insertVariableStatements()`.
+
+```ts
+import { Project, VariableDeclarationKind } from "ts-morph";
+
+const variableStatement = sourceFile.addVariableStatement({
+  declarationKind: VariableDeclarationKind.Const, // defaults to "let"
+  declarations: [{
+    name: "myNumber",
+    initializer: "5",
+  }, {
+    name: "myString",
+    type: "string",
+    initializer: `'my string'`,
+  }],
+});
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+variableStatement.remove();
+```
+
+### Declaration type
+
+Get:
+
+```ts
+const declarationKind = variableStatement.getDeclarationKind();
+```
+
+It will return one of the following values:
+
+```ts
+import { VariableDeclarationKind } from "ts-morph";
+
+VariableDeclarationKind.Let;
+VariableDeclarationKind.Const;
+VariableDeclarationKind.Var;
+```
+
+Set:
+
+```ts
+variableStatement.setDeclarationKind(VariableDeclarationKind.Const);
+```
+
+## Variable Declaration
+
+These are the individual declarations within a variable statement.
+
+### Get variable declaration
+
+Get them from the variable statement:
+
+```ts
+const variableDeclarations = variableStatement.getDeclarations();
+```
+
+Or from source files, namespaces, and function bodies:
+
+```ts
+const variableDeclarations = sourceFile.getVariableDeclarations();
+const variableDeclaration = sourceFile.getVariableDeclaration("myVar");
+const firstStringTypedVariableDeclaration = sourceFile.getVariableDeclaration(v => v.getType().getText() === "string");
+```
+
+### Add/Insert
+
+Add or insert variable declarations to a variable statement by calling `addDeclaration()`, `addDeclarations()`,
+`insertDeclaration()`, or `insertDeclarations()`.
+
+```ts
+const declaration = variableStatement.addDeclaration({ name: "num", type: "number" });
+```
+
+### Remove
+
+Call `.remove()`:
+
+```ts
+variableDeclaration.remove();
+```

package/vendor/ts-morph/docs/emitting.md

@@ -0,0 +1,151 @@
+---
+title: Emitting
+---
+
+## Emitting
+
+Emitting is is the process of taking the original TypeScript files and outputting them as JavaScript (`.js`) and/or declaration files (`.d.ts`).
+
+Here's an example:
+
+```ts
+const project = new Project({ compilerOptions: { outDir: "dist", declaration: true } });
+project.createSourceFile("MyFile.ts", "const num = 1;");
+project.emit(); // async
+
+// or
+project.emitSync(); // slow
+```
+
+This outputs two files in the `dist` folder:
+
+```ts
+// MyFile.js
+var num = 1;
+
+// MyFile.d.ts
+declare const num = 1;
+```
+
+### Emitting a single file
+
+Call `.emit()` on the source file:
+
+```ts
+const sourceFile = project.getSourceFileOrThrow("MyFile.ts");
+sourceFile.emit(); // async, fast
+
+// or
+sourceFile.emitSync(); // slow
+```
+
+Or get its emit output:
+
+```ts
+const emitOutput = sourceFile.getEmitOutput();
+emitOutput.getEmitSkipped(); // returns: boolean
+for (const outputFile of emitOutput.getOutputFiles()) {
+  outputFile.getFilePath();
+  outputFile.getWriteByteOrderMark();
+  outputFile.getText();
+}
+```
+
+### Emitting only declaration files (.d.ts)
+
+Specify the `emitOnlyDtsFiles` flag:
+
+```ts
+project.emit({ emitOnlyDtsFiles: true });
+```
+
+### Emit Diagnostics
+
+Diagnostics about the emit can be found on the result:
+
+```ts
+const emitResult = await project.emit();
+for (const diagnostic of emitResult.getDiagnostics())
+  console.log(diagnostic.getMessageText());
+```
+
+These are good to always check when emitting to ensure everything went smoothly. They will explain why files aren't being emitted.
+
+### Emitting with custom transformations
+
+You can emit using the compiler API's custom transformations by specifying them on the `customTransformers` option.
+
+The following example will emit the code with all numeric literals change to string literals:
+
+```ts
+project.emit({
+  customTransformers: {
+    // optional transformers to evaluate before built in .js transformations
+    before: [context => sourceFile => visitSourceFile(sourceFile, context, numericLiteralToStringLiteral)],
+    // optional transformers to evaluate after built in .js transformations
+    after: [],
+    // optional transformers to evaluate after built in .d.ts transformations
+    afterDeclarations: [],
+  },
+});
+
+function visitSourceFile(
+  sourceFile: ts.SourceFile,
+  context: ts.TransformationContext,
+  visitNode: (node: ts.Node, context: ts.TransformationContext) => ts.Node,
+) {
+  return visitNodeAndChildren(sourceFile) as ts.SourceFile;
+
+  function visitNodeAndChildren(node: ts.Node): ts.Node {
+    return ts.visitEachChild(visitNode(node, context), visitNodeAndChildren, context);
+  }
+}
+
+function numericLiteralToStringLiteral(node: ts.Node, context: ts.TransformationContext) {
+  if (ts.isNumericLiteral(node))
+    return context.factory.createStringLiteral(node.text);
+  return node;
+}
+```
+
+## Emitting to Memory
+
+If you don't want to emit to the file system, you can call `emitToMemory()`:
+
+```ts
+const project = new Project({ compilerOptions: { outDir: "dist" } });
+project.createSourceFile("MyFile.ts", "const num = 1;");
+const result = project.emitToMemory();
+
+// output the emitted files to the console
+for (const file of result.getFiles()) {
+  console.log("----");
+  console.log(file.filePath);
+  console.log("----");
+  console.log(file.text);
+  console.log("\n");
+}
+
+// or finally save this result to the underlying file system (or use `saveFilesSync()`)
+result.saveFiles().then(() => console.log("written"));
+```
+
+To manipulate after emitting, you may load the result into a new project and manipulate that:
+
+```ts
+const project = new Project({ compilerOptions: { outDir: "dist" } });
+project.createSourceFile("MyFile.ts", "const num = 1;");
+const result = project.emitToMemory();
+
+// load the javascript files into a new project
+const newProject = new Project();
+for (const file of result.getFiles())
+  newProject.createSourceFile(file.filePath, file.text, { overwrite: true });
+
+// ...manipulate the javascript files here...
+
+// save the new files to the file system
+await newProject.save();
+```
+
+...but consider using the custom transformers discussed above if you want it to be faster.

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

@@ -0,0 +1,25 @@
+---
+title: Documentation
+---
+
+## Purpose
+
+Setup, navigation, and manipulation of the TypeScript AST can be a challenge. This library wraps the TypeScript compiler API so it's simple.
+
+## Installing
+
+Install as usual via npm:
+
+```
+npm install --save-dev ts-morph
+```
+
+Or if you're using Deno and want to install via JSR:
+
+```
+deno add ts-morph@jsr:@ts-morph/ts-morph
+```
+
+## Documentation Progress
+
+I've been still slowly updating the documentation. I'm keeping it up to date with any new features, but some existing features don't have documentation.

package/vendor/ts-morph/docs/manipulation/code-writer.md

@@ -0,0 +1,20 @@
+---
+title: Code Writer
+---
+
+## Code Writer
+
+With manipulation methods that accept a `string` for the new code, it's possible to write text using a provided [code-block-writer](https://github.com/dsherret/code-block-writer).
+
+Using the writer is very useful because it will write code out using the indentation and newline settings of the project. It's also easier to use.
+
+### Example
+
+```ts
+functionDeclaration.setBodyText(writer =>
+  writer.writeLine("let myNumber = 5;")
+    .write("if (myNumber === 5)").block(() => {
+      writer.writeLine("console.log('yes')");
+    })
+);
+```

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

@@ -0,0 +1,76 @@
+---
+title: Formatting
+---
+
+## Formatting
+
+Sometimes you might encounter code that looks terrible. For example:
+
+<!-- dprint-ignore -->
+```ts
+// BadlyFormattedFile.ts
+var myVariable     :      string |    number;
+function myFunction(param    : string){
+return "";
+}
+```
+
+Automatically format the text of this file by calling format text on it:
+
+```ts
+sourceFile.formatText();
+// or provide optional formatting settings
+sourceFile.formatText({
+  placeOpenBraceOnNewLineForFunctions: true,
+});
+```
+
+This will run the source file's text through the TypeScript compiler's formatting API, which will change the source file to contain the following text:
+
+```ts
+// BadlyFormattedFile.ts (not anymore!)
+var myVariable: string | number;
+function myFunction(param: string) {
+  return "";
+}
+```
+
+### Individual Nodes
+
+Individual nodes can also be formatted. For example, say you have a file that looks like this:
+
+<!-- dprint-ignore -->
+```ts
+// file.ts
+export class MyClass {
+    prop  !  : string   ;
+
+    myMethod(    example: string    ) {
+  console.log(    example    );
+    }
+}
+```
+
+You can select down to the specific node you want to format:
+
+```ts
+project.getSourceFileOrThrow("file.ts")
+  .getClassOrThrow("MyClass")
+  .getInstanceMethodOrThrow("myMethod")
+  .getStatements()[0]
+  .formatText();
+```
+
+Which would selectively only format the first statement in the method:
+
+<!-- dprint-ignore -->
+```ts
+// file.ts
+export class MyClass {
+    prop  !  : string   ;
+
+    myMethod(    example: string    ) {
+        console.log(example);
+    }
+}
+```