fcis 0.1.0

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

@@ -0,0 +1,65 @@
+{
+  "name": "@ts-morph/common",
+  "version": "0.28.1",
+  "description": "Common functionality for ts-morph packages.",
+  "main": "dist/ts-morph-common.js",
+  "author": "David Sherret",
+  "license": "MIT",
+  "repository": "git+https://github.com/dsherret/ts-morph.git",
+  "types": "lib/ts-morph-common.d.ts",
+  "scripts": {
+    "build": "deno task build:declarations && deno task build:node",
+    "build:node": "rimraf dist && deno task createLibFile && deno task rollup && deno run -A scripts/bundleLocalTs.ts",
+    "build:deno": "rimraf ../../deno/common && rimraf dist-deno && deno task rollup --environment BUILD:deno && deno task build:declarations && deno run -A scripts/buildDeno.ts",
+    "build:declarations": "deno run -A scripts/buildDeclarations.ts",
+    "createLibFile": "deno run -A scripts/createLibFile.ts",
+    "test": "deno run -A npm:mocha",
+    "test:ci": "deno task test",
+    "test:debug": "deno task test --inspect-brk",
+    "rollup": "rollup --config"
+  },
+  "dependencies": {
+    "minimatch": "^10.0.1",
+    "path-browserify": "^1.0.1",
+    "tinyglobby": "^0.2.14"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/chai": "^5.2.1",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.14.1",
+    "chai": "^5.2.0",
+    "cross-env": "^7.0.3",
+    "mocha": "^11.1.0",
+    "rimraf": "^6.0.1",
+    "rollup": "=4.40.0",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "typescript": "5.9.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "browser": {
+    "fs": false,
+    "node:fs": false,
+    "fs/promises": false,
+    "node:fs/promises": false,
+    "os": false,
+    "node:os": false,
+    "fs.realpath": false,
+    "mkdirp": false,
+    "dir-glob": false,
+    "graceful-fs": false,
+    "tinyglobby": false,
+    "source-map-support": false,
+    "glob-parent": false,
+    "glob": false,
+    "path": false,
+    "node:path": false,
+    "crypto": false,
+    "buffer": false,
+    "@microsoft/typescript-etw": false,
+    "inspector": false
+  }
+}

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

@@ -0,0 +1,5 @@
+# @ts-morph/common
+
+Common functionality for [ts-morph](../ts-morph) and [@ts-morph/bootstrap](../bootstrap).
+
+Please do not depend on this library!

package/vendor/ts-morph/packages/scripts/changeTypeScriptVersion.ts

@@ -0,0 +1,28 @@
+import { path, tsMorph } from "./deps.ts";
+import { folders } from "./folders.ts";
+const { Project, SyntaxKind } = tsMorph;
+
+export function changeTypeScriptVersion(version: string) {
+  setModuleSpecifierValue(`typescript-${version}`);
+}
+
+export function resetTypeScriptVersion() {
+  setModuleSpecifierValue("typescript");
+}
+
+function setModuleSpecifierValue(value: string) {
+  const project = new Project();
+  const declarationFile = project.addSourceFileAtPath(path.join(folders.common, "lib/ts-morph-common.d.ts"));
+  const jsFile = project.addSourceFileAtPath(path.join(folders.common, "dist/ts-morph-common.js"));
+
+  for (const importDec of declarationFile.getImportDeclarations()) {
+    const moduleSpecifierValue = importDec.getModuleSpecifierValue();
+    if (moduleSpecifierValue.startsWith("typescript"))
+      importDec.setModuleSpecifier(value);
+  }
+
+  const callExpr = jsFile.getVariableDeclarationOrThrow("ts").getInitializerIfKindOrThrow(SyntaxKind.CallExpression);
+  callExpr.getArguments()[0].asKindOrThrow(SyntaxKind.StringLiteral).setLiteralValue(value);
+
+  [declarationFile, jsFile].forEach(s => s.saveSync());
+}

package/vendor/ts-morph/packages/scripts/createDeclarationProject.ts

@@ -0,0 +1,47 @@
+import { tsMorph } from "./deps.ts";
+import { printDiagnostics } from "./utils/mod.ts";
+const { IndentationText, NewLineKind, Project } = tsMorph;
+
+export interface CreateDeclarationProjectOptions {
+  tsConfigFilePath: string;
+}
+
+export function createDeclarationProject(opts: CreateDeclarationProjectOptions) {
+  const project = new Project({
+    tsConfigFilePath: opts.tsConfigFilePath,
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+      newLineKind: NewLineKind.LineFeed,
+    },
+    compilerOptions: {
+      declaration: true,
+    },
+  });
+
+  const emitResult = project.emitToMemory({ emitOnlyDtsFiles: true });
+
+  if (emitResult.getDiagnostics().length > 0) {
+    printDiagnostics(emitResult.getDiagnostics());
+    Deno.exit(1);
+  }
+
+  const declarationProject = new Project({
+    tsConfigFilePath: opts.tsConfigFilePath,
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+      newLineKind: NewLineKind.LineFeed,
+    },
+    skipAddingFilesFromTsConfig: true,
+  });
+
+  for (const file of emitResult.getFiles())
+    declarationProject.createSourceFile(file.filePath, file.text, { overwrite: true });
+
+  const declDiagnostics = declarationProject.getPreEmitDiagnostics();
+  if (declDiagnostics.length > 0) {
+    console.log(declarationProject.formatDiagnosticsWithColorAndContext(declDiagnostics));
+    Deno.exit(1);
+  }
+
+  return declarationProject;
+}

package/vendor/ts-morph/packages/scripts/deps.ts

@@ -0,0 +1,2 @@
+export * as path from "https://deno.land/std@0.208.0/path/mod.ts";
+export * as tsMorph from "jsr:@ts-morph/ts-morph";

package/vendor/ts-morph/packages/scripts/execScript.ts

@@ -0,0 +1,31 @@
+async function execScript(command: string, args: string[], cwd: string) {
+  const p = Deno.run({
+    cwd,
+    cmd: [command, ...args],
+    stderr: "piped",
+    stdout: "piped",
+  });
+
+  const [status, stdout, stderr] = await Promise.all([
+    p.status(),
+    p.output(),
+    p.stderrOutput(),
+  ]);
+  p.close();
+
+  if (!status.success) {
+    throw new Error(
+      `Error executing ${command} ${args.join(" ")}: ${new TextDecoder().decode(stderr)}`,
+    );
+  }
+
+  return new TextDecoder().decode(stdout);
+}
+
+export function execNpmScript(scriptName: string, cwd: string) {
+  return execScript(
+    "npm",
+    ["run", scriptName, "--no-update-notifier", "--scripts-prepend-node-path"],
+    cwd,
+  );
+}

package/vendor/ts-morph/packages/scripts/folders.ts

@@ -0,0 +1,11 @@
+import { path } from "./deps.ts";
+
+const dirname = path.dirname(path.fromFileUrl(import.meta.url));
+const root = path.join(dirname, "../../");
+export const folders = {
+  scripts: path.join(root, "./packages/scripts"),
+  common: path.join(root, "./packages/common"),
+  bootstrap: path.join(root, "./packages/bootstrap"),
+  tsMorph: path.join(root, "./packages/ts-morph"),
+  root,
+};

package/vendor/ts-morph/packages/scripts/getDevCompilerVersions.ts

@@ -0,0 +1,19 @@
+import { path } from "./deps.ts";
+import { folders } from "./folders.ts";
+
+export function getDevCompilerVersions() {
+  const fileData = JSON.parse(Deno.readTextFileSync(path.join(folders.common, "package.json")));
+  const dependencies = fileData["devDependencies"];
+  const keyRegEx = /^typescript(-[0-9]+\.[0-9]+\.[0-9]+)$/;
+  const versionRegEx = /[0-9]+\.[0-9]+\.[0-9]+/;
+  const versions: { version: string; name: string }[] = [];
+
+  for (const key of Object.keys(dependencies)) {
+    if (!keyRegEx.test(key))
+      continue;
+    const matches = versionRegEx.exec(dependencies[key]);
+    versions.push({ version: matches![0], name: key });
+  }
+
+  return versions.sort((a, b) => a.version > b.version ? -1 : 1);
+}

package/vendor/ts-morph/packages/scripts/mod.ts

@@ -0,0 +1,7 @@
+export * from "./changeTypeScriptVersion.ts";
+export * from "./createDeclarationProject.ts";
+export { path, tsMorph } from "./deps.ts";
+export * from "./execScript.ts";
+export * from "./folders.ts";
+export * from "./getDevCompilerVersions.ts";
+export * from "./utils/mod.ts";

package/vendor/ts-morph/packages/scripts/utils/Memoize.ts

@@ -0,0 +1,36 @@
+/** Decorator for memoizing the result of a method. */
+export function Memoize(target: any, context: DecoratorContext) {
+  if (context.kind === "method" || context.kind === "getter")
+    return getNewFunction(target);
+  else
+    throw new Error("Not implemented.");
+}
+
+const weakMap = new WeakMap<object, Map<string, unknown>>();
+
+let counter = 0;
+function getNewFunction(originalFunction: Function) {
+  const identifier = counter++;
+  function decorator(this: any, ...args: any[]) {
+    let propertyValues = weakMap.get(this);
+    if (propertyValues == null) {
+      propertyValues = new Map<string, unknown>();
+      weakMap.set(this, propertyValues);
+    }
+    let propName = `__memoized_value_${identifier}`;
+    if (arguments.length > 0)
+      propName += "_" + JSON.stringify(args);
+    let returnedValue: any;
+
+    if (propertyValues.has(propName))
+      returnedValue = propertyValues.get(propName);
+    else {
+      returnedValue = originalFunction.apply(this, args);
+      propertyValues.set(propName, returnedValue);
+    }
+
+    return returnedValue;
+  }
+
+  return decorator;
+}

package/vendor/ts-morph/packages/scripts/utils/forEachTypeText.ts

@@ -0,0 +1,23 @@
+import { tsMorph } from "../deps.ts";
+
+export function forEachTypeText(structure: tsMorph.Structures, func: (typeText: string) => string) {
+  forEachChild(structure);
+
+  function forEachChild(child: tsMorph.Structures) {
+    if (tsMorph.Structure.isTyped(child) && child.type != null)
+      child.type = withType(child.type);
+    if (tsMorph.Structure.isReturnTyped(child) && child.returnType != null)
+      child.returnType = withType(child.returnType);
+    if (tsMorph.Structure.isTypeParameter(child) && child.constraint != null)
+      child.constraint = withType(child.constraint);
+
+    tsMorph.forEachStructureChild(child, forEachChild);
+  }
+
+  function withType(text: string | tsMorph.WriterFunction) {
+    if (typeof text !== "string")
+      throw new Error("Unhandled scenario where the type text was not a string.");
+
+    return func(text);
+  }
+}

package/vendor/ts-morph/packages/scripts/utils/makeConstructorsPrivate.ts

@@ -0,0 +1,26 @@
+import { tsMorph } from "../deps.ts";
+
+export function makeConstructorsPrivate(mainFile: tsMorph.SourceFile) {
+  forEachDescendant(mainFile);
+
+  function forEachDescendant(node: tsMorph.Node) {
+    node.forEachChild(forEachDescendant);
+
+    if (tsMorph.Node.isClassDeclaration(node))
+      withClass(node);
+
+    if (!tsMorph.Node.isSourceFile(node))
+      node.forget();
+
+    function withClass(classDec: tsMorph.ClassDeclaration) {
+      for (const ctor of classDec.getConstructors()) {
+        const hasPrivateTag = ctor.getJsDocs().some(doc => doc.getTags().some(tag => tag.getTagName() === "private"));
+        if (hasPrivateTag) {
+          ctor.getParameters().forEach(p => p.remove());
+          ctor.getJsDocs().forEach(d => d.remove());
+          ctor.setScope(classDec.getDerivedClasses().length > 0 ? tsMorph.Scope.Protected : tsMorph.Scope.Private);
+        }
+      }
+    }
+  }
+}

package/vendor/ts-morph/packages/scripts/utils/mod.ts

@@ -0,0 +1,4 @@
+export * from "./forEachTypeText.ts";
+export * from "./makeConstructorsPrivate.ts";
+export * from "./Memoize.ts";
+export * from "./printDiagnostics.ts";

package/vendor/ts-morph/packages/scripts/utils/printDiagnostics.ts

@@ -0,0 +1,10 @@
+import { tsMorph } from "../deps.ts";
+
+/** Prints the provided diagnostics with colour and context. */
+export function printDiagnostics(diagnostics: tsMorph.Diagnostic[]) {
+  console.log(tsMorph.ts.formatDiagnosticsWithColorAndContext(diagnostics.map(d => d.compilerObject), {
+    getCurrentDirectory: () => Deno.cwd(),
+    getCanonicalFileName: fileName => fileName,
+    getNewLine: () => "\n",
+  }));
+}

package/vendor/ts-morph/packages/ts-morph/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 David Sherret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.