ts2famix 2.1.0-beta.2 → 3.1.0

package/src/lib/ts-complex/cyclomatic-service.ts

@@ -1,83 +1,83 @@
-/*
-Portions of this file:
-
-MIT License
-
-Copyright (c) 2018 Anand Undavia
-
-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.
-*/
-
-import { forEachChild, isIdentifier, SyntaxKind, createSourceFile, ScriptTarget, Node, CaseClause, BinaryExpression, FunctionLikeDeclaration } from 'typescript';
-import { isFunctionWithBody } from 'tsutils';
-import { existsSync, PathLike, readFileSync } from 'fs';
-
-const getNodeName = (node: FunctionLikeDeclaration) => {
-  const { name, pos, end } = node;
-  const key = name !== undefined && isIdentifier(name) ? name.text : JSON.stringify({ pos, end });
-  return key;
-};
-
-const increasesComplexity = (node: Node) => {
-  /* eslint-disable indent */
-  switch (node.kind) {
-    case SyntaxKind.CaseClause:
-      return (node as CaseClause).statements.length > 0;
-    case SyntaxKind.CatchClause:
-    case SyntaxKind.ConditionalExpression:
-    case SyntaxKind.DoStatement:
-    case SyntaxKind.ForStatement:
-    case SyntaxKind.ForInStatement:
-    case SyntaxKind.ForOfStatement:
-    case SyntaxKind.IfStatement:
-    case SyntaxKind.WhileStatement:
-      return true;
-
-    case SyntaxKind.BinaryExpression:
-      switch ((node as BinaryExpression).operatorToken.kind) {
-        case SyntaxKind.BarBarToken:
-        case SyntaxKind.AmpersandAmpersandToken:
-          return true;
-        default:
-          return false;
-      }
-
-    default:
-      return false;
-  }
-  /* eslint-enable indent */
-};
-
-const calculateFromSource = (ctx: Node) => {
-  let complexity = 0;
-  const output: { [key: string]: number } = {};
-  forEachChild(ctx, function cb(node) {
-    if (isFunctionWithBody(node)) {
-      const old = complexity;
-      complexity = 1;
-      forEachChild(node, cb);
-      const name = getNodeName(node)?.toString();
-      output[name] = complexity;
-      complexity = old;
-    } else {
-      if (increasesComplexity(node)) {
-        complexity += 1;
-      }
-      forEachChild(node, cb);
-    }
-  });
-  return output;
-};
-
-export const calculate = (filePath: PathLike) => {
-  if (!existsSync(filePath)) {
-    throw new Error(`File "${filePath}" does not exists`);
-  }
-  const sourceText = readFileSync(filePath).toString();
-  const source = createSourceFile(filePath.toString(), sourceText, ScriptTarget.ES2015);
-  return calculateFromSource(source);
-};
+/*
+Portions of this file:
+
+MIT License
+
+Copyright (c) 2018 Anand Undavia
+
+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.
+*/
+
+import { forEachChild, isIdentifier, SyntaxKind, createSourceFile, ScriptTarget, Node, CaseClause, BinaryExpression, FunctionLikeDeclaration } from 'typescript';
+import { isFunctionWithBody } from 'tsutils';
+import { existsSync, PathLike, readFileSync } from 'fs';
+
+const getNodeName = (node: FunctionLikeDeclaration) => {
+  const { name, pos, end } = node;
+  const key = name !== undefined && isIdentifier(name) ? name.text : JSON.stringify({ pos, end });
+  return key;
+};
+
+const increasesComplexity = (node: Node) => {
+  /* eslint-disable indent */
+  switch (node.kind) {
+    case SyntaxKind.CaseClause:
+      return (node as CaseClause).statements.length > 0;
+    case SyntaxKind.CatchClause:
+    case SyntaxKind.ConditionalExpression:
+    case SyntaxKind.DoStatement:
+    case SyntaxKind.ForStatement:
+    case SyntaxKind.ForInStatement:
+    case SyntaxKind.ForOfStatement:
+    case SyntaxKind.IfStatement:
+    case SyntaxKind.WhileStatement:
+      return true;
+
+    case SyntaxKind.BinaryExpression:
+      switch ((node as BinaryExpression).operatorToken.kind) {
+        case SyntaxKind.BarBarToken:
+        case SyntaxKind.AmpersandAmpersandToken:
+          return true;
+        default:
+          return false;
+      }
+
+    default:
+      return false;
+  }
+  /* eslint-enable indent */
+};
+
+const calculateFromSource = (ctx: Node) => {
+  let complexity = 0;
+  const output: { [key: string]: number } = {};
+  forEachChild(ctx, function cb(node) {
+    if (isFunctionWithBody(node)) {
+      const old = complexity;
+      complexity = 1;
+      forEachChild(node, cb);
+      const name = getNodeName(node)?.toString();
+      output[name] = complexity;
+      complexity = old;
+    } else {
+      if (increasesComplexity(node)) {
+        complexity += 1;
+      }
+      forEachChild(node, cb);
+    }
+  });
+  return output;
+};
+
+export const calculate = (filePath: PathLike) => {
+  if (!existsSync(filePath)) {
+    throw new Error(`File "${filePath}" does not exists`);
+  }
+  const sourceText = readFileSync(filePath).toString();
+  const source = createSourceFile(filePath.toString(), sourceText, ScriptTarget.ES2015);
+  return calculateFromSource(source);
+};

package/src/refactorer/refactor-getter-setter.ts

@@ -1,140 +1,140 @@
-import { ClassDeclaration, Project, SourceFile, SyntaxKind } from "ts-morph";
-import * as path from "path";
-
-const project = new Project();
-project.addSourceFilesAtPaths("src/lib/famix/model/famix/famix_base_element.ts");
-project.getSourceFiles().forEach(sourceFile => { console.log(sourceFile.getFilePath()); });
-
-project.getSourceFiles().forEach(sourceFile => {
-    const typeMap = createTypeMap(sourceFile);
-
-    const classes = sourceFile.getClasses();
-    classes.forEach(cls => {
-        const properties = cls.getProperties();
-        cls.getMethods().forEach(method => {
-            const methodName = method.getName();
-            let propName: string;
-
-            if (isEligibleGetter(methodName)) {
-                propName = methodName.charAt(3).toLowerCase() + methodName.slice(4);
-                renamePropertyIfExists(cls, propName, properties);
-                refactorToGetter(cls, method, propName, typeMap);
-                replaceMethodCalls(cls, `get${capitalize(propName)}`, propName);
-            } else if (isEligibleSetter(methodName)) {
-                propName = methodName.charAt(3).toLowerCase() + methodName.slice(4);
-                renamePropertyIfExists(cls, propName, properties);
-                refactorToSetter(cls, method, propName, typeMap);
-                replaceMethodCalls(cls, `set${capitalize(propName)}`, propName);
-            }
-        });
-    });
-});
-
-project.save().then(() => {
-    console.log("Refactoring complete!");
-});
-
-function isEligibleGetter(methodName: string): boolean {
-    return methodName.startsWith("get") && /^[A-Z][a-zA-Z0-9]*$/.test(methodName.slice(3)) && !methodName.includes("JSON");
-}
-
-function isEligibleSetter(methodName: string): boolean {
-    return methodName.startsWith("set") && /^[A-Z][a-zA-Z0-9]*$/.test(methodName.slice(3));
-}
-
-function renamePropertyIfExists(cls: any, propName: string, properties: any[]) {
-    const existingProperty = properties.find(prop => prop.getName() === propName);
-    if (existingProperty) {
-        existingProperty.rename(`_${propName}`);
-    }
-}
-
-function createTypeMap(sourceFile: SourceFile): Map<string, string> {
-    const typeMap = new Map<string, string>();
-    const importDeclarations = sourceFile.getImportDeclarations();
-
-    importDeclarations.forEach(importDecl => {
-        const moduleSpecifier = importDecl.getModuleSpecifier().getText().replace(/['"]/g, '');
-        const absolutePath = path.resolve(sourceFile.getDirectory().getPath(), moduleSpecifier);
-        const normalizedPath = normalizePath(absolutePath);
-        const namedImports = importDecl.getNamedImports();
-        const defaultImport = importDecl.getDefaultImport();
-
-        namedImports.forEach(namedImport => {
-            console.log(`Named import: ${namedImport.getName()}, path: ${normalizedPath}`);
-            typeMap.set(namedImport.getName(), normalizedPath);
-        });
-
-        if (defaultImport) {
-            typeMap.set(defaultImport.getText(), normalizedPath);
-        }
-    });
-
-    return typeMap;
-}
-
-function refactorToGetter(cls: any, method: any, propName: string, typeMap: Map<string, string>) {
-    const getterName = propName;
-    const renamedProp = `_${propName}`;
-    const returnType = method.getReturnType().getText();
-    const simplifiedType = replaceLongTypePaths(returnType, typeMap);
-
-    const getterBody = method.getBodyText().replace(new RegExp(`this\\.${propName}`, 'g'), `this.${renamedProp}`);
-
-    cls.addGetAccessor({
-        name: getterName,
-        statements: getterBody,
-        // returnType: simplifiedType,  // don't need a return type for getter
-    });
-
-    method.remove();
-}
-
-function refactorToSetter(cls: any, method: any, propName: string, typeMap: Map<string, string>) {
-    const setterName = propName;
-    const renamedProp = `_${propName}`;
-
-    const parameter = method.getParameters()[0];
-    const paramName = parameter.getName();
-    const paramType = replaceLongTypePaths(parameter.getType().getText(), typeMap);
-
-    const setterBody = method.getBodyText().replace(new RegExp(`this\\.${propName}`, 'g'), `this.${renamedProp}`);
-
-    cls.addSetAccessor({
-        name: setterName,
-        statements: setterBody,
-        parameters: [{ name: paramName, type: paramType }],
-    });
-
-    method.remove();
-}
-
-function replaceLongTypePaths(type: string, typeMap: Map<string, string>): string {
-    for (const [importName, importPath] of typeMap.entries()) {
-        const longPath = `import("${importPath}")${importName}`;
-        const regex = new RegExp(`import\\(["']${normalizePath(importPath)}["']\\)\\.${importName}`, 'g');
-        if (regex.test(type)) {
-            return importName;
-        }
-    }
-    return type;
-}
-
-function normalizePath(filePath: string): string {
-    return filePath.replace(/\\/g, '/');
-}
-
-function replaceMethodCalls(cls: ClassDeclaration, methodName: string, propName: string) {
-    cls.getDescendantsOfKind(SyntaxKind.CallExpression).forEach(callExpr => {
-        const expr = callExpr.getExpression();
-        if (expr.getText() === `this.${methodName}`) {
-            callExpr.replaceWithText(`this.${propName}`);
-        } else if (expr.getText() === `this.${methodName}` && callExpr.getArguments().length > 0) {
-            callExpr.replaceWithText(`this.${propName} = ${callExpr.getArguments()[0].getText()}`);
-        }
-    });
-}
-
-function capitalize(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
+import { ClassDeclaration, Project, SourceFile, SyntaxKind } from "ts-morph";
+import * as path from "path";
+
+const project = new Project();
+project.addSourceFilesAtPaths("src/lib/famix/model/famix/famix_base_element.ts");
+project.getSourceFiles().forEach(sourceFile => { console.log(sourceFile.getFilePath()); });
+
+project.getSourceFiles().forEach(sourceFile => {
+    const typeMap = createTypeMap(sourceFile);
+
+    const classes = sourceFile.getClasses();
+    classes.forEach(cls => {
+        const properties = cls.getProperties();
+        cls.getMethods().forEach(method => {
+            const methodName = method.getName();
+            let propName: string;
+
+            if (isEligibleGetter(methodName)) {
+                propName = methodName.charAt(3).toLowerCase() + methodName.slice(4);
+                renamePropertyIfExists(cls, propName, properties);
+                refactorToGetter(cls, method, propName, typeMap);
+                replaceMethodCalls(cls, `get${capitalize(propName)}`, propName);
+            } else if (isEligibleSetter(methodName)) {
+                propName = methodName.charAt(3).toLowerCase() + methodName.slice(4);
+                renamePropertyIfExists(cls, propName, properties);
+                refactorToSetter(cls, method, propName, typeMap);
+                replaceMethodCalls(cls, `set${capitalize(propName)}`, propName);
+            }
+        });
+    });
+});
+
+project.save().then(() => {
+    console.log("Refactoring complete!");
+});
+
+function isEligibleGetter(methodName: string): boolean {
+    return methodName.startsWith("get") && /^[A-Z][a-zA-Z0-9]*$/.test(methodName.slice(3)) && !methodName.includes("JSON");
+}
+
+function isEligibleSetter(methodName: string): boolean {
+    return methodName.startsWith("set") && /^[A-Z][a-zA-Z0-9]*$/.test(methodName.slice(3));
+}
+
+function renamePropertyIfExists(cls: any, propName: string, properties: any[]) {
+    const existingProperty = properties.find(prop => prop.getName() === propName);
+    if (existingProperty) {
+        existingProperty.rename(`_${propName}`);
+    }
+}
+
+function createTypeMap(sourceFile: SourceFile): Map<string, string> {
+    const typeMap = new Map<string, string>();
+    const importDeclarations = sourceFile.getImportDeclarations();
+
+    importDeclarations.forEach(importDecl => {
+        const moduleSpecifier = importDecl.getModuleSpecifier().getText().replace(/['"]/g, '');
+        const absolutePath = path.resolve(sourceFile.getDirectory().getPath(), moduleSpecifier);
+        const normalizedPath = normalizePath(absolutePath);
+        const namedImports = importDecl.getNamedImports();
+        const defaultImport = importDecl.getDefaultImport();
+
+        namedImports.forEach(namedImport => {
+            console.log(`Named import: ${namedImport.getName()}, path: ${normalizedPath}`);
+            typeMap.set(namedImport.getName(), normalizedPath);
+        });
+
+        if (defaultImport) {
+            typeMap.set(defaultImport.getText(), normalizedPath);
+        }
+    });
+
+    return typeMap;
+}
+
+function refactorToGetter(cls: any, method: any, propName: string, typeMap: Map<string, string>) {
+    const getterName = propName;
+    const renamedProp = `_${propName}`;
+    const returnType = method.getReturnType().getText();
+    const simplifiedType = replaceLongTypePaths(returnType, typeMap);
+
+    const getterBody = method.getBodyText().replace(new RegExp(`this\\.${propName}`, 'g'), `this.${renamedProp}`);
+
+    cls.addGetAccessor({
+        name: getterName,
+        statements: getterBody,
+        // returnType: simplifiedType,  // don't need a return type for getter
+    });
+
+    method.remove();
+}
+
+function refactorToSetter(cls: any, method: any, propName: string, typeMap: Map<string, string>) {
+    const setterName = propName;
+    const renamedProp = `_${propName}`;
+
+    const parameter = method.getParameters()[0];
+    const paramName = parameter.getName();
+    const paramType = replaceLongTypePaths(parameter.getType().getText(), typeMap);
+
+    const setterBody = method.getBodyText().replace(new RegExp(`this\\.${propName}`, 'g'), `this.${renamedProp}`);
+
+    cls.addSetAccessor({
+        name: setterName,
+        statements: setterBody,
+        parameters: [{ name: paramName, type: paramType }],
+    });
+
+    method.remove();
+}
+
+function replaceLongTypePaths(type: string, typeMap: Map<string, string>): string {
+    for (const [importName, importPath] of typeMap.entries()) {
+        const longPath = `import("${importPath}")${importName}`;
+        const regex = new RegExp(`import\\(["']${normalizePath(importPath)}["']\\)\\.${importName}`, 'g');
+        if (regex.test(type)) {
+            return importName;
+        }
+    }
+    return type;
+}
+
+function normalizePath(filePath: string): string {
+    return filePath.replace(/\\/g, '/');
+}
+
+function replaceMethodCalls(cls: ClassDeclaration, methodName: string, propName: string) {
+    cls.getDescendantsOfKind(SyntaxKind.CallExpression).forEach(callExpr => {
+        const expr = callExpr.getExpression();
+        if (expr.getText() === `this.${methodName}`) {
+            callExpr.replaceWithText(`this.${propName}`);
+        } else if (expr.getText() === `this.${methodName}` && callExpr.getArguments().length > 0) {
+            callExpr.replaceWithText(`this.${propName} = ${callExpr.getArguments()[0].getText()}`);
+        }
+    });
+}
+
+function capitalize(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/ts2famix-cli-wrapper.ts

@@ -1,21 +1,21 @@
-#!/usr/bin/env node
-
-import { spawn } from 'child_process';
-import * as path from 'path';
-
-// Resolve the path to ts2famix-cli.js relative to the wrapper script
-const cliPath = path.resolve(__dirname, 'ts2famix-cli.js');
-
-// Allow tslog to display the proper TypeScript files and line numbers
-const args = [
-  '--enable-source-maps',
-  '--experimental-specifier-resolution=node',
-  cliPath,
-  ...process.argv.slice(2)
-];
-
-const child = spawn('node', args, { stdio: 'inherit' });
-
-child.on('close', (code) => {
-  process.exit(code);
-});
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import * as path from 'path';
+
+// Resolve the path to ts2famix-cli.js relative to the wrapper script
+const cliPath = path.resolve(__dirname, 'ts2famix-cli.js');
+
+// Allow tslog to display the proper TypeScript files and line numbers
+const args = [
+  '--enable-source-maps',
+  '--experimental-specifier-resolution=node',
+  cliPath,
+  ...process.argv.slice(2)
+];
+
+const child = spawn('node', args, { stdio: 'inherit' });
+
+child.on('close', (code) => {
+  process.exit(code);
+});

package/src/ts2famix-cli.ts

@@ -1,60 +1,62 @@
-#!/usr/bin/env node
-import * as fs from "fs";
-import yargs from "yargs";
-import { Importer } from './analyze';
-import { FamixRepository } from "./lib/famix/famix_repository";
-import { Project } from "ts-morph";
-import { config } from "./analyze";
-
-const argv = yargs
-    .example(`ts2famix -i "path/to/project/**/*.ts" -o JSONModels/projectName.json`, 'Creates a JSON-format Famix model of typescript files.')
-    .example(`ts2famix -i path/to/tsconfig.json -o JSONModels/projectName.json`, 'Creates a JSON-format model of a typescript project.')
-    .alias('i', 'input')
-    .nargs('i', 1)
-    .alias('o', 'output')
-    .nargs('o', 1)
-    .alias('l', 'loglevel')
-    .nargs('l', 1)
-    .default('l', 3)
-    .describe('l', 'Set minimum logging level 0: silly, 1: trace, 2: debug, 3: info, 4: warn, 5: error, 6: fatal')
-    .boolean('graphemes')
-    .default('graphemes', false)
-    .describe('graphemes', 'Process graphemes (outside of the BMP) to avoid source anchor offset errors (due to performance issues, this is disabled by default)')
-    .demandOption('input')
-    .demandOption('output')
-    .parseSync();
-
-import { logger } from './analyze';
-logger.settings.minLevel = Number(argv.loglevel) as number;
-config.expectGraphemes = argv.graphemes as boolean;
-
-const importer = new Importer();
-let famixRep: FamixRepository;
-
-if ((argv.input as string).endsWith('tsconfig.json')) {
-    const tsConfigFilePath = argv.input as string;
-    // get the baseUrl from the tsconfig file
-    const baseUrl = tsConfigFilePath.substring(0, tsConfigFilePath.lastIndexOf('/'));
-    logger.info(`baseUrl: ${baseUrl}`);
-    const project = new Project({
-        tsConfigFilePath,
-        compilerOptions: {
-            baseUrl: baseUrl,
-        }
-      }); 
-    famixRep = importer.famixRepFromProject(project);
-
-} else {
-    const paths = new Array<string>();
-    paths.push(argv.input as string);
-    famixRep = importer.famixRepFromPaths(paths);
-}
-
-const jsonOutput = famixRep.export({format: "json"});
-const jsonFilePath = argv.output as string;
-
-fs.writeFile(jsonFilePath, jsonOutput, (err) => {
-    if (err) { throw err; }
-});
-
-logger.info(`Created: ${jsonFilePath}`); 
+#!/usr/bin/env node
+import * as fs from "fs";
+import yargs from "yargs";
+import { Importer } from './analyze';
+import { FamixRepository } from "./lib/famix/famix_repository";
+import { Project } from "ts-morph";
+import { config } from "./analyze";
+
+const argv = yargs
+    .example(`ts2famix -i "path/to/project/**/*.ts" -o JSONModels/projectName.json`, 'Creates a JSON-format Famix model of typescript files.')
+    .example(`ts2famix -i path/to/tsconfig.json -o JSONModels/projectName.json`, 'Creates a JSON-format model of a typescript project.')
+    .version()
+    .alias('v', 'version')
+    .alias('i', 'input')
+    .nargs('i', 1)
+    .alias('o', 'output')
+    .nargs('o', 1)
+    .alias('l', 'loglevel')
+    .nargs('l', 1)
+    .default('l', 3)
+    .describe('l', 'Set minimum logging level 0: silly, 1: trace, 2: debug, 3: info, 4: warn, 5: error, 6: fatal')
+    .boolean('graphemes')
+    .default('graphemes', false)
+    .describe('graphemes', 'Process graphemes (outside of the BMP) to avoid source anchor offset errors (due to performance issues, this is disabled by default)')
+    .demandOption('input')
+    .demandOption('output')
+    .parseSync();
+
+import { logger } from './analyze';
+logger.settings.minLevel = Number(argv.loglevel) as number;
+config.expectGraphemes = argv.graphemes as boolean;
+
+const importer = new Importer();
+let famixRep: FamixRepository;
+
+if ((argv.input as string).endsWith('tsconfig.json')) {
+    const tsConfigFilePath = argv.input as string;
+    // get the baseUrl from the tsconfig file
+    const baseUrl = tsConfigFilePath.substring(0, tsConfigFilePath.lastIndexOf('/'));
+    logger.info(`baseUrl: ${baseUrl}`);
+    const project = new Project({
+        tsConfigFilePath,
+        compilerOptions: {
+            baseUrl: baseUrl,
+        }
+      }); 
+    famixRep = importer.famixRepFromProject(project);
+
+} else {
+    const paths = new Array<string>();
+    paths.push(argv.input as string);
+    famixRep = importer.famixRepFromPaths(paths);
+}
+
+const jsonOutput = famixRep.export({format: "json"});
+const jsonFilePath = argv.output as string;
+
+fs.writeFile(jsonFilePath, jsonOutput, (err) => {
+    if (err) { throw err; }
+});
+
+logger.info(`Created: ${jsonFilePath}`); 

package/tsconfig.check-tests.json

@@ -1,14 +1,14 @@
-{
-    "compilerOptions": {
-      "target": "ES2020",
-      "module": "commonjs",
-      "strict": false,
-      "esModuleInterop": true,
-      "skipLibCheck": true,
-      "forceConsistentCasingInFileNames": true,
-      "noEmit": true
-    },
-    "include": [
-      "test/**/*.ts"
-    ]
-  }
+{
+    "compilerOptions": {
+      "target": "ES2020",
+      "module": "commonjs",
+      "strict": false,
+      "esModuleInterop": true,
+      "skipLibCheck": true,
+      "forceConsistentCasingInFileNames": true,
+      "noEmit": true
+    },
+    "include": [
+      "test/**/*.ts"
+    ]
+  }