fcis 0.1.0

package/vendor/ts-morph/packages/ts-morph/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "ts-morph",
+  "version": "27.0.2",
+  "description": "TypeScript compiler wrapper for static analysis and code manipulation.",
+  "main": "dist/ts-morph.js",
+  "types": "lib/ts-morph.d.ts",
+  "scripts": {
+    "dopublish": "deno task type-check-docs && deno task code-generate && deno task package && deno task publish-code-verification && echo \"Run: npm publish\"",
+    "build": "deno task build:declarations && deno task build:node",
+    "build:node": "rimraf dist && rollup -c ",
+    "build:deno": "deno task build:declarations && rimraf dist-deno && rollup -c --environment BUILD:deno && deno run -A scripts/buildDeno.ts",
+    "build:declarations": "deno run -A scripts/generation/main.ts create-declaration-file",
+    "test": "deno run -A npm:mocha",
+    "test:debug": "deno task test --inspect-brk",
+    "test:watch": "deno task test --watch-extensions ts --watch",
+    "test:ci": "deno task test",
+    "test:ts-versions": "deno run -A scripts/test/testTypeScriptVersions.ts",
+    "type-check": "deno run -A scripts/typeCheckLibrary.ts",
+    "code-generate": "deno run -A scripts/generation/main.ts",
+    "output-wrapped-nodes": "deno run -A scripts/generation/outputWrappedNodesInfo.ts",
+    "package": "deno task build",
+    "publish-code-verification": "deno task code-verification && deno task ensure-no-declaration-file-errors",
+    "code-verification": "deno run -A scripts/verification/main.ts ensure-structures-match-classes ensure-overload-structures-match ensure-array-inputs-readonly ensure-classes-implement-structure-methods ensure-mixin-not-applied-multiple-times validate-public-api-class-member-names validate-compiler-node-to-wrapped-type validate-code-fences",
+    "ensure-structures-match-classes": "deno run -A scripts/verification/main.ts ensure-structures-match-classes",
+    "ensure-overload-structures-match": "deno run -A scripts/verification/main.ts ensure-overload-structures-match",
+    "ensure-no-project-compile-errors": "deno run -A scripts/verification/ensureNoProjectCompileErrors.ts",
+    "ensure-no-declaration-file-errors": "deno run -A scripts/verification/ensureNoDeclarationFileErrors.ts",
+    "ensure-array-inputs-readonly": "deno run -A scripts/verification/main ensure-array-inputs-readonly.ts",
+    "ensure-or-throw-exists": "deno run -A scripts/verification/main ensure-or-throw-exists.ts",
+    "type-check-docs": "deno run -A scripts/typeCheckDocumentation.ts"
+  },
+  "repository": "git+https://github.com/dsherret/ts-morph.git",
+  "keywords": [
+    "typescript",
+    "ast",
+    "static analysis",
+    "code generation",
+    "code refactor"
+  ],
+  "author": "David Sherret",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dsherret/ts-morph/issues"
+  },
+  "homepage": "https://github.com/dsherret/ts-morph#readme",
+  "dependencies": {
+    "@ts-morph/common": "~0.28.1",
+    "code-block-writer": "^13.0.3"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/chai": "^5.2.1",
+    "@types/diff": "^7.0.2",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.14.1",
+    "chai": "^5.2.0",
+    "conditional-type-checks": "^1.0.6",
+    "cross-env": "^7.0.3",
+    "diff": "^7.0.0",
+    "mocha": "11.1.0",
+    "rimraf": "^6.0.1",
+    "rollup": "=4.40.0",
+    "ts-node": "10.9.2",
+    "typescript": "~5.9.2"
+  },
+  "browser": {
+    "fs": false,
+    "os": false,
+    "fs.realpath": false,
+    "mkdirp": false,
+    "dir-glob": false,
+    "graceful-fs": false,
+    "source-map-support": false,
+    "glob-parent": false,
+    "glob": false,
+    "tinyglobby": false
+  }
+}

package/vendor/ts-morph/packages/ts-morph/readme.md

@@ -0,0 +1,111 @@
+# ts-morph
+
+[![npm version](https://badge.fury.io/js/ts-morph.svg)](https://badge.fury.io/js/ts-morph)
+[![CI](https://github.com/dsherret/ts-morph/workflows/CI/badge.svg)](https://github.com/dsherret/ts-morph/actions?query=workflow%3ACI)
+[![stable](http://badges.github.io/stability-badges/dist/stable.svg)](http://github.com/badges/stability-badges)
+
+[TypeScript](https://github.com/Microsoft/TypeScript) Compiler API wrapper. Provides an easier way to programmatically navigate and manipulate TypeScript and JavaScript code.
+
+Formerly `ts-simple-ast`.
+
+## Overview
+
+- [Documentation](https://ts-morph.com/)
+- [Declaration file](https://github.com/dsherret/ts-morph/blob/latest/packages/ts-morph/lib/ts-morph.d.ts)
+
+## Main Features
+
+1. Wraps the compiler API objects to provide helper methods for getting information and programmatically changing files.
+2. Allows falling back to the compiler API objects if necessary (ex. `classDeclaration.compilerNode` or `typeChecker.compilerObject`).
+3. All changes are kept in memory (including file and directory moves) until specifying to save to the underlying file system.
+4. Changes are made to the text and wrapped nodes can be held on to between manipulations.
+
+## Getting Started
+
+1. [Installing](https://ts-morph.com/)
+2. [Instantiating](https://ts-morph.com/setup/)
+3. [Adding source files](https://ts-morph.com/setup/adding-source-files)
+4. [Getting source files](https://ts-morph.com/navigation/getting-source-files)
+5. [Navigating](https://ts-morph.com/navigation/example)
+6. [Manipulating](https://ts-morph.com/manipulation/)
+
+## Library Progress
+
+This library is still under active development. Most common code manipulation/generation use cases are implemented, but there's still a lot of work to do. Please open an issue if you find a feature missing, bug, or question that isn't in the issue tracker.
+
+- [Breaking changes](https://github.com/dsherret/ts-morph/blob/latest/packages/ts-morph/breaking-changes.md)
+- [Change log](https://github.com/dsherret/ts-morph/blob/latest/packages/ts-morph/CHANGELOG.md)
+- [Wrapped nodes progress report](https://github.com/dsherret/ts-morph/blob/latest/packages/ts-morph/wrapped-nodes.md)
+
+## Example
+
+<!-- dprint-ignore -->
+```ts
+import { Project, StructureKind } from "ts-morph";
+
+// initialize
+const project = new Project({
+    // Optionally specify compiler options, tsconfig.json, in-memory file system, and more here.
+    // If you initialize with a tsconfig.json, then it will automatically populate the project
+    // with the associated source files.
+    // Read more: https://ts-morph.com/setup/
+});
+
+// add source files
+project.addSourceFilesAtPaths("src/**/*.ts");
+const myClassFile = project.createSourceFile("src/MyClass.ts", "export class MyClass {}");
+const myEnumFile = project.createSourceFile("src/MyEnum.ts", {
+    statements: [{
+        kind: StructureKind.Enum,
+        name: "MyEnum",
+        isExported: true,
+        members: [{ name: "member" }],
+    }],
+});
+
+// get information
+const myClass = myClassFile.getClassOrThrow("MyClass");
+myClass.getName();          // returns: "MyClass"
+myClass.hasExportKeyword(); // returns: true
+myClass.isDefaultExport();  // returns: false
+
+// manipulate
+const myInterface = myClassFile.addInterface({
+    name: "IMyInterface",
+    isExported: true,
+    properties: [{
+        name: "myProp",
+        type: "number",
+    }],
+});
+
+myClass.rename("NewName");
+myClass.addImplements(myInterface.getName());
+myClass.addProperty({
+    name: "myProp",
+    initializer: "5",
+});
+
+project.getSourceFileOrThrow("src/ExistingFile.ts").delete();
+
+// asynchronously save all the changes above
+await project.save();
+
+// get underlying compiler node from the typescript AST from any node
+const compilerNode = myClassFile.compilerNode;
+```
+
+Or navigate existing compiler nodes created with the TypeScript compiler (the `ts` named export is the TypeScript compiler):
+
+```ts ignore-error: 1109
+import { createWrappedNode, ClassDeclaration, ts } from "ts-morph";
+
+// some code that creates a class declaration using the ts object
+const classNode: ts.ClassDeclaration = ...;
+
+// create and use a wrapped node
+const classDec = createWrappedNode(classNode) as ClassDeclaration;
+const firstProperty = classDec.getProperties()[0];
+
+// ... do more stuff here ...
+```

package/vendor/ts-morph/readme.md

@@ -0,0 +1,14 @@
+# ts-morph
+
+[![CI](https://github.com/dsherret/ts-morph/workflows/CI/badge.svg)](https://github.com/dsherret/ts-morph/actions?query=workflow%3ACI)
+
+Monorepo for [ts-morph](packages/ts-morph) and related projects.
+
+## Packages
+
+- [ts-morph](packages/ts-morph) - TypeScript Compiler API wrapper. Provides an easier way to programmatically navigate and manipulate TypeScript and JavaScript code.
+- [@ts-morph/bootstrap](packages/bootstrap) - Separate library for getting quickly setup with the Compiler API.
+
+## Resources
+
+- [TypeScript AST Viewer](https://ts-ast-viewer.com)

package/vendor/ts-morph/rfcs/README.md

@@ -0,0 +1,13 @@
+# RFCs
+
+This is a very loose RFC process. The implementation may slightly differ.
+
+[Issues](https://github.com/dsherret/ts-morph/issues?utf8=%E2%9C%93&q=label%3A%22requires+proposal%22+)
+
+## Implemented
+
+- [RFC-0001](RFC-0001 - Inserting Into Statements Handling Comments.md) - Inserting into statements handling comments.
+
+## In Progress
+
+- None

package/vendor/ts-morph/rfcs/RFC-0001 - Inserting Into Statements Handling Comments.md

@@ -0,0 +1,181 @@
+# RFC-0001 - Inserting Into Statements Handling Comments
+
+Ported from: https://github.com/dsherret/ts-morph/issues/575
+
+## Prerequisites
+
+- Understand comment ownership: https://github.com/Microsoft/TypeScript/wiki/Architectural-Overview#trivia
+- Current api is for inserting statements: `insertStatements(index: number, statements: string | WriterFunction | (string | WriterFunction)[]): Statement[];` where `index` is the `node.statements` array index of the node.
+
+## Issues
+
+- [#189](https://github.com/dsherret/ts-morph/issues/189) - Node inserted before comment when calling `addClass`-like methods
+- [#565](https://github.com/dsherret/ts-morph/issues/565) - Inserting at a specific position
+
+## Overview
+
+The parser rightfully excludes comments from the AST in order to reduce complexity in the compiler. The compiler API then provides a way to get the comments via the `ts.getLeadingCommentRanges` and `ts.getTrailingCommentRanges` functions. These functions are provided the source file text and position to know where to start parsing at.
+
+Although not so useful for the compilation process, comments are useful to know about for programmatic refactoring purposes in certain scenarios.
+
+For example, given the following code:
+
+```ts
+// initialize
+const u = 5;
+```
+
+How could one say to insert after the comment?
+
+```ts
+// initialize
+const t = 4;
+const u = 5;
+```
+
+Or before?
+
+```ts
+const t = 4;
+// this value is special
+const u = 5;
+```
+
+Right now, there doesn't exist an easy way to do this in ts-morph (possible by inserting with `insertText`, which takes a position).
+
+## Option 1: Insert API Change
+
+One option would be to change the API for `insertStatements` to take a position.
+
+### Upsides
+
+- Close functionality to the compiler API.
+
+### Downsides
+
+- API is not intuitive.
+- Users confused why comments aren't a statement (had people ask about this multiple times).
+- Users will need to parse for comments themselves in order to find out they're there.
+
+## Option 2: Leading Comments as Statements
+
+Given the following code:
+
+```ts
+// comment 1
+/* comment 2 */
+/* comment 3 */ const t = 4; // comment 4
+const u = 5;
+```
+
+Calling `.getStatementsWithComments()` would return any leading comments that are on a different line at the start of the line.
+
+```
+{
+    kind: ts.SyntaxKind.SingleLineCommentTrivia,
+    text: "// comment 1"
+}, {
+    kind: ts.SyntaxKind.MultiLineCommentTrivia,
+    text: "/* comment 2 */"
+}, {
+    kind: ts.SyntaxKind.VariableStatement,
+    // ...etc...
+}
+```
+
+So in other words, trailing comments are never included as well as leading comments on the same line.
+
+### JS Docs
+
+JS docs will not be considered a statement unless they do not have a following declaration.
+
+### Comment on same line as header
+
+```ts
+function getResult() { // description
+  return 5;
+}
+```
+
+This comment should be ignored and considered as a trialing comment of the header. Most of the time these are a description of the header and not useful to know about for statemented purposes.
+
+### No actual statements, but has comments
+
+For example, given the following source file:
+
+```ts
+// comment 1
+/* comment 2 */
+```
+
+It should return both comments when calling `#getStatementsWithComments()`.
+
+### Multiple comments on same line
+
+This is an edge case, but if someone does the following:
+
+<!-- dprint-ignore -->
+```ts
+/* comment 1 */ // comment 2
+/* comment 3 */ /* comment 4 */ // comment 5
+```
+
+Then it should just return comment 1 and 3. Comment 2, 4, and 5 should return as a trailing comments of their respective comment nodes.
+
+### Preceding comment on same line as close brace token
+
+This comment should be parsed as if it's a member if it has no other token on the same line.
+
+<!-- dprint-ignore -->
+```ts
+class C {
+    prop;
+    /* test */ }
+```
+
+The reason is that generally if someone writes this they would have meant to place it on the next line and so it shouldn't hide the comment.
+
+### Other areas
+
+It is also useful, but less so, to know about comments in nodes that have members (ex. class, interface, enum, object literal expression, type element expression, etc. members). In these cases, a separate `#getMembersWithComments()`/`#getPropertiesWithComments()`-like methods will be added.
+
+### Node methods
+
+One annoyance might be that standard `Node` methods like `#getStart()` aren't available. To fix this, the compiler node should actually be parsed to extend `ts.Node` then have an `ExtendedCommentNode` class that extends from `Node`.
+
+### `#getPos()`
+
+Behaviour should always stay the same as the compiler api. That means node positions may overlap comment positions (as already occurs). This behaviour is similar to JS doc comments.
+
+### `#getChildren()`
+
+`#getChildren()` should be updated in order to return these newly parsed comments.
+
+Ultimately I have decided to break away from the compiler API here because the code becomes too complex when I don't consider these as children. Returning the comments with `#getChildren()` also ensures the comments are counted when calling `#getChildIndex()`.
+
+### `#forEachChild`
+
+`#forEachChild` will remain the same. It's better to keep this change as limited as possible.
+
+### `#getChildIndex()`
+
+This method will return the index in the result of `#getChildren()`.
+
+### `#getChildCount()`
+
+Should be updated to instead return the result of `#getChildren().length` (not use the compiler api value).
+
+### Conditional behaviour?
+
+Should this behaviour be conditional (ex. `parseComments: false` or something in the project options)? No, that would increase the complexity far too much.
+
+### Benefits
+
+- Users approaching the problem for the first time do not understand why comments are not considered statements. It might be more intuitive to do this.
+- Makes it very easy to deal with comments and decide whether to insert before or after one (or remove them).
+
+### Drawbacks
+
+- Might confuse some users who are used to the compiler api behaviour when using `#getChildren()`.
+  - This is slightly unfortunate, but users would be even more confused about methods like `#getChildIndex()` not including comments. It would also increase complexity internally within the library.
+  - Most users won't have any experience with the compiler API so this is probably not an issue.

package/vendor/ts-morph/tsconfig.common.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "CommonJS",
+    "strict": true,
+    "sourceMap": false,
+    "removeComments": false,
+    "experimentalDecorators": false,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "newLine": "lf",
+    "importHelpers": false
+  },
+  "compileOnSave": false
+}

package/vitest.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: ['src/**/*.ts'],
+      exclude: ['src/cli.ts', 'src/index.ts'],
+    },
+    testTimeout: 10000,
+  },
+})