@teambit/doctor 0.0.1

package/doctor-cmd.ts

@@ -0,0 +1,97 @@
+import runAll, { DoctorOptions, listDiagnoses, runOne } from './doctor';
+import { Command, CommandOptions } from '@teambit/cli';
+import formatDiagnosesList from './diagnosis-list-template';
+import formatDiagnosesResult from './doctor-results-template';
+
+type Flags = {
+  list?: boolean;
+  save?: string;
+  archive?: string;
+  includeNodeModules?: boolean;
+  includePublic?: boolean;
+  excludeLocalScope?: boolean;
+};
+
+export class DoctorCmd implements Command {
+  name = 'doctor [diagnosis-name]';
+  description = 'diagnose a bit workspace';
+  group = 'general';
+  alias = '';
+  loadAspects = false;
+  options = [
+    ['j', 'json', 'return diagnoses in json format'],
+    ['', 'list', 'list all available diagnoses'],
+    ['s', 'save [filePath]', 'save diagnoses to a file'],
+    [
+      'a',
+      'archive [filePath]',
+      'archive the workspace including diagnosis info (by default exclude node-modules and include .bit)',
+    ],
+    ['n', 'include-node-modules', 'relevant for --archive. include node_modules in the archive file'],
+    ['p', 'include-public', 'relevant for --archive. include public folder in the archive file'],
+    ['e', 'exclude-local-scope', 'relevant for --archive. exclude .bit or .git/bit from the archive file'],
+  ] as CommandOptions;
+
+  async report([diagnosisName]: string[], flags: Flags) {
+    const res = await this.runDiag(diagnosisName, flags);
+    if (flags.list) {
+      return formatDiagnosesList(res);
+    }
+    if (diagnosisName) {
+      const { examineResult, savedFilePath, metaData } = res;
+      return formatDiagnosesResult({ examineResults: [examineResult], savedFilePath, metaData });
+    }
+    const { examineResults, savedFilePath, metaData } = res;
+    return formatDiagnosesResult({ examineResults, savedFilePath, metaData });
+  }
+
+  async json([diagnosisName]: string[], flags: Flags) {
+    const res = await this.runDiag(diagnosisName, flags);
+    if (flags.list) {
+      return res;
+    }
+    const { examineResults, examineResult, savedFilePath } = res;
+    const fullJson = {
+      savedFilePath,
+      examineResult,
+      examineResults,
+    };
+    return fullJson;
+  }
+
+  private async runDiag(diagnosisName?: string, flags: Flags = {}): Promise<any> {
+    const {
+      list = false,
+      save,
+      archive,
+      includeNodeModules = false,
+      includePublic = false,
+      excludeLocalScope = false,
+    } = flags;
+
+    if (list) {
+      return listDiagnoses();
+    }
+    if ((includeNodeModules || excludeLocalScope) && !archive) {
+      throw new Error('to use --include-node-modules or --exclude-local-scope please specify --archive');
+    }
+    let filePath = save;
+    // Happen when used --save without specify the location
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    if (save === true || archive === true) {
+      filePath = '.';
+    }
+    if (typeof archive === 'string') {
+      filePath = archive;
+    }
+    const doctorOptions: DoctorOptions = {
+      diagnosisName,
+      filePath,
+      archiveWorkspace: Boolean(archive),
+      includeNodeModules,
+      includePublic,
+      excludeLocalScope,
+    };
+    return diagnosisName ? runOne(doctorOptions) : runAll(doctorOptions);
+  }
+}

package/doctor-registrar-builder.ts

@@ -0,0 +1,22 @@
+import BrokenSymlinkFiles from './core-diagnoses/broken-symlink-files';
+import OrphanSymlinkObjects from './core-diagnoses/orphan-symlink-objects';
+import ValidateBitVersion from './core-diagnoses/validate-bit-version';
+import ValidateGitExec from './core-diagnoses/validate-git-exec';
+import ValidateNpmExec from './core-diagnoses/validate-npm-exec';
+import ValidateWorkspaceBitJsonSyntax from './core-diagnoses/validate-workspace-bit-json-syntax';
+import ValidateYarnExec from './core-diagnoses/validate-yarn-exec';
+import Diagnosis from './diagnosis';
+import DoctorRegistrar from './doctor-registrar';
+
+export default function registerCoreAndExtensionsDiagnoses(extensionDiagnoses: Diagnosis[] = []) {
+  const diagnoses = [
+    new ValidateWorkspaceBitJsonSyntax(),
+    new ValidateGitExec(),
+    new OrphanSymlinkObjects(),
+    new BrokenSymlinkFiles(),
+    new ValidateNpmExec(),
+    new ValidateYarnExec(),
+    new ValidateBitVersion(),
+  ].concat(extensionDiagnoses);
+  DoctorRegistrar.init(diagnoses);
+}

package/doctor-registrar.ts

@@ -0,0 +1,58 @@
+import Diagnosis from './diagnosis';
+
+/*
+ * Setting up block level variable to store class state
+ * set's to null by default.
+ */
+let instance: DoctorRegistrar | null = null;
+
+const _checkName = (name) => (diagnosis: Diagnosis) => {
+  return diagnosis.name === name;
+};
+
+export default class DoctorRegistrar {
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  diagnoses: Diagnosis[];
+
+  constructor() {
+    if (!instance) {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      instance = this;
+    }
+
+    return instance;
+  }
+
+  /**
+   * Initialize the default diagnoses
+   */
+  static init(diagnoses: Diagnosis[] = []) {
+    const self = new DoctorRegistrar();
+    self.diagnoses = diagnoses;
+    // diagnoses.forEach(diagnosis => self.diagnoses.push(diagnosis));
+  }
+
+  /**
+   * Get the instance of the DoctorRegistrar
+   * @return {DoctorRegistrar} instance of the DoctorRegistrar
+   *
+   */
+  static getInstance(): DoctorRegistrar {
+    if (!instance) {
+      DoctorRegistrar.init();
+    }
+    return instance as DoctorRegistrar;
+  }
+
+  /**
+   * Register a new diagnosis
+   * @param {Diagnosis} diagnosis
+   */
+  registerDiagnosis(diagnosis: Diagnosis) {
+    this.diagnoses.push(diagnosis);
+  }
+
+  getDiagnosisByName(name: string) {
+    return this.diagnoses.find(_checkName(name));
+  }
+}

package/doctor-results-template.ts

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import { table } from 'table';
+import { DoctorMetaData, DoctorRunAllResults } from './doctor';
+import { ExamineResult } from './diagnosis';
+
+// const NAME_COLUMN_WIDTH = 100;
+// const DESCRIPTION_COLUMN_WIDTH = 30;
+
+const summeryTableColumnConfig = {
+  columnDefault: {
+    alignment: 'left',
+  },
+};
+
+type SummeryRow = [string, string, string, string];
+
+function _formatStatusCell(status: boolean): string {
+  if (status) {
+    return chalk.green('passed');
+  }
+  return chalk.red('failed');
+}
+
+function _createSummeryRow(examineResult: ExamineResult): SummeryRow {
+  const meta = examineResult.diagnosisMetaData;
+  const status = _formatStatusCell(examineResult.bareResult.valid);
+  return [meta.category, meta.name, meta.description, status];
+}
+
+function _createSummeryTable(examineResult: ExamineResult[]): string {
+  const header = [chalk.bold('category'), chalk.bold('name'), chalk.bold('description'), chalk.bold('status')];
+  const rows = examineResult.map(_createSummeryRow);
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  rows.unshift(header);
+  const output = table(rows, summeryTableColumnConfig);
+  return output;
+}
+
+function _createSummerySection(examineResult: ExamineResult[]): string {
+  // A placeholder if we will decide we want a title
+  const title = chalk.underline('');
+  const summeryTable = _createSummeryTable(examineResult);
+  return `${title}\n${summeryTable}`;
+}
+
+function _createFullReportForDiagnosis(examineResult: ExamineResult): string {
+  if (examineResult.bareResult.valid) {
+    return '';
+  }
+  const title = chalk.underline(examineResult.diagnosisMetaData.name);
+  const symptomsTitle = chalk.underline('symptoms');
+  const symptomsText = examineResult.formattedSymptoms;
+  const cureTitle = chalk.underline('cure');
+  const cureText = examineResult.formattedManualTreat;
+  return `${title}
+  ${symptomsTitle}
+  ${symptomsText}
+  ${cureTitle}
+  ${cureText}\n`;
+}
+
+function _createFullReportForDiagnoses(examineResult: ExamineResult[]): string {
+  const fullDiagnosesReport = examineResult.map(_createFullReportForDiagnosis).join('\n');
+  return fullDiagnosesReport;
+}
+
+function _createFullReportSection(examineResult: ExamineResult[]): string {
+  const title = chalk.underline('Error report');
+  const fullDiagnosesReport = _createFullReportForDiagnoses(examineResult);
+  if (fullDiagnosesReport.trim() === '') {
+    return '';
+  }
+  return `${title}
+${fullDiagnosesReport}`;
+}
+
+function _createWrittenFileSection(savedFilePath) {
+  if (!savedFilePath) {
+    return '';
+  }
+  return `File written to ${savedFilePath}`;
+}
+
+function _createMetaSection(metaData: DoctorMetaData) {
+  return `
+  bit version   : ${metaData.bitVersion}
+  node version  : ${metaData.nodeVersion}
+  npm version   : ${metaData.npmVersion || 'NA'}
+  yarn version  : ${metaData.yarnVersion || 'NA'}
+  platform      : ${metaData.platform}
+  user details  : ${metaData.userDetails}
+`;
+}
+
+export default function render({ examineResults, savedFilePath, metaData }: DoctorRunAllResults): string {
+  const meatSection = _createMetaSection(metaData);
+  const summerySection = _createSummerySection(examineResults);
+  const fullReportSection = _createFullReportSection(examineResults);
+  const writtenFileSection = _createWrittenFileSection(savedFilePath);
+  const output = `${meatSection}
+${summerySection}
+${fullReportSection}
+${writtenFileSection}`;
+  return output;
+}

package/doctor.aspect.ts

@@ -0,0 +1,5 @@
+import { Aspect } from '@teambit/harmony';
+
+export const DoctorAspect = Aspect.create({
+  id: 'teambit.harmony/doctor',
+});

package/doctor.main.runtime.ts

@@ -0,0 +1,17 @@
+import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
+import { DoctorAspect } from './doctor.aspect';
+import { DoctorCmd } from './doctor-cmd';
+
+export class DoctorMain {
+  static slots = [];
+  static dependencies = [CLIAspect];
+  static runtime = MainRuntime;
+  static async provider([cliMain]: [CLIMain]) {
+    cliMain.register(new DoctorCmd());
+    return new DoctorMain();
+  }
+}
+
+DoctorAspect.addRuntime(DoctorMain);
+
+export default DoctorMain;

package/doctor.ts

@@ -0,0 +1,250 @@
+import fs from 'fs-extra';
+import os from 'os';
+// @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+import Stream from 'stream';
+import path from 'path';
+import tar from 'tar-stream';
+import tarFS from 'tar-fs';
+import { getHarmonyVersion } from '@teambit/legacy/dist/bootstrap';
+import { CFG_USER_EMAIL_KEY, CFG_USER_NAME_KEY, DEBUG_LOG } from '@teambit/legacy/dist/constants';
+import BitMap from '@teambit/legacy/dist/consumer/bit-map';
+import WorkspaceConfig from '@teambit/legacy/dist/consumer/config/workspace-config';
+import { ConsumerInfo, getConsumerInfo } from '@teambit/legacy/dist/consumer/consumer-locator';
+import Diagnosis, { ExamineResult } from './diagnosis';
+import DoctorRegistrar from './doctor-registrar';
+import registerCoreAndExtensionsDiagnoses from './doctor-registrar-builder';
+import logger from '@teambit/legacy/dist/logger/logger';
+import { getExt, getWithoutExt, removeChalkCharacters } from '@teambit/legacy/dist/utils';
+import { findScopePath } from '@teambit/scope.modules.find-scope-path';
+import * as globalConfig from '@teambit/legacy/dist/api/consumer/lib/global-config';
+import { getNpmVersion } from './core-diagnoses/validate-npm-exec';
+import { getYarnVersion } from './core-diagnoses/validate-yarn-exec';
+import { DiagnosisNotFound } from './exceptions/diagnosis-not-found';
+import { MissingDiagnosisName } from './exceptions/missing-diagnosis-name';
+
+// run specific check
+export type DoctorMetaData = {
+  nodeVersion: string;
+  runningTimestamp: number;
+  platform: string;
+  bitVersion: string;
+  npmVersion: string;
+  yarnVersion: string;
+  userDetails: string;
+};
+export type DoctorRunAllResults = {
+  examineResults: ExamineResult[];
+  savedFilePath: string | null | undefined;
+  metaData: DoctorMetaData;
+};
+export type DoctorRunOneResult = {
+  examineResult: ExamineResult;
+  savedFilePath: string | null | undefined;
+  metaData: DoctorMetaData;
+};
+
+let runningTimeStamp;
+
+export type DoctorOptions = {
+  diagnosisName?: string;
+  filePath?: string;
+  archiveWorkspace?: boolean;
+  includeNodeModules?: boolean;
+  includePublic?: boolean;
+  excludeLocalScope?: boolean;
+};
+
+export default async function runAll(options: DoctorOptions): Promise<DoctorRunAllResults> {
+  registerCoreAndExtensionsDiagnoses();
+  runningTimeStamp = _getTimeStamp();
+  const doctorRegistrar = DoctorRegistrar.getInstance();
+  const examineP = doctorRegistrar.diagnoses.map((diagnosis) => diagnosis.examine());
+  const examineResults = await Promise.all(examineP);
+  const envMeta = await _getEnvMeta();
+  const savedFilePath = await _saveExamineResultsToFile(examineResults, envMeta, options);
+  return { examineResults, savedFilePath, metaData: envMeta };
+}
+
+export async function runOne({ diagnosisName, ...options }: DoctorOptions): Promise<DoctorRunOneResult> {
+  if (!diagnosisName) {
+    throw new MissingDiagnosisName();
+  }
+  registerCoreAndExtensionsDiagnoses();
+  runningTimeStamp = _getTimeStamp();
+  const doctorRegistrar = DoctorRegistrar.getInstance();
+  const diagnosis = doctorRegistrar.getDiagnosisByName(diagnosisName);
+  if (!diagnosis) {
+    throw new DiagnosisNotFound(diagnosisName);
+  }
+  const examineResult = await diagnosis.examine();
+  const envMeta = await _getEnvMeta();
+  const savedFilePath = await _saveExamineResultsToFile([examineResult], envMeta, options);
+  return { examineResult, savedFilePath, metaData: envMeta };
+}
+
+export async function listDiagnoses(): Promise<Diagnosis[]> {
+  registerCoreAndExtensionsDiagnoses();
+  const doctorRegistrar = DoctorRegistrar.getInstance();
+  return Promise.resolve(doctorRegistrar.diagnoses);
+}
+
+async function _saveExamineResultsToFile(
+  examineResults: ExamineResult[],
+  envMeta: DoctorMetaData,
+  options: DoctorOptions
+): Promise<string | null | undefined> {
+  if (!options.filePath) {
+    return Promise.resolve(undefined);
+  }
+  const finalFilePath = _calculateFinalFileName(options.filePath);
+  const packStream = await _generateExamineResultsTarFile(examineResults, envMeta, finalFilePath, options);
+
+  const yourTarball = fs.createWriteStream(finalFilePath);
+
+  packStream.pipe(yourTarball);
+
+  return new Promise((resolve) => {
+    yourTarball.on('close', function () {
+      logger.info(`wrote a file by bit doctor, file path: ${finalFilePath}`);
+      resolve(finalFilePath);
+      // fs.stat(finalFilePath, function (err, stats) {
+      //   if (err) throw err
+      //   console.log(stats)
+      //   console.log('Got file info successfully!')
+      // })
+    });
+  });
+}
+
+function _calculateFinalFileName(fileName: string): string {
+  if (fileName === '.') {
+    return _getDefaultFileName();
+  }
+  let finalFileName = fileName;
+  if (getExt(fileName) !== 'tar' && getExt(fileName) !== 'tar.gz') {
+    finalFileName = `${getWithoutExt(finalFileName)}.tar`;
+  }
+  return finalFileName;
+}
+
+function _getDefaultFileName() {
+  const timestamp = runningTimeStamp || _getTimeStamp();
+  return `doctor-results-${timestamp}.tar`;
+}
+
+// TODO: move to utils
+function _getTimeStamp() {
+  const d = new Date();
+  const timestamp = d.getTime();
+  return timestamp;
+}
+
+async function _generateExamineResultsTarFile(
+  examineResults: ExamineResult[],
+  envMeta: DoctorMetaData,
+  tarFilePath: string,
+  options: DoctorOptions
+): Promise<Stream.Readable> {
+  const { archiveWorkspace, includeNodeModules, includePublic, excludeLocalScope } = options;
+  const debugLog = await _getDebugLogAsBuffer();
+  const consumerInfo = await _getConsumerInfo();
+  let bitmap;
+  if (consumerInfo && consumerInfo.path) {
+    bitmap = _getBitMap(consumerInfo.path);
+  }
+
+  const packExamineResults = async (pack) => {
+    pack.entry({ name: 'env-meta.json' }, JSON.stringify(envMeta, null, 2));
+    pack.entry({ name: 'doc-results.json' }, JSON.stringify(examineResults, null, 2));
+    if (debugLog) {
+      pack.entry({ name: 'debug.log' }, debugLog);
+    }
+    if (!archiveWorkspace && bitmap) {
+      pack.entry({ name: '.bitmap' }, bitmap);
+    }
+    if (consumerInfo && consumerInfo.hasConsumerConfig) {
+      // TODO: support new config as well
+      const scopePath = findScopePath(consumerInfo.path);
+      const config = scopePath ? await WorkspaceConfig.loadIfExist(consumerInfo.path, scopePath) : undefined;
+      const legacyPlainConfig = config?._legacyPlainObject();
+      if (legacyPlainConfig) {
+        pack.entry({ name: 'config.json' }, JSON.stringify(legacyPlainConfig, null, 4));
+      }
+    }
+
+    pack.finalize();
+
+    return pack;
+  };
+
+  if (!archiveWorkspace) {
+    const pack = tar.pack(); // pack is a streams2 stream
+    return packExamineResults(pack);
+  }
+
+  const ignore = (fileName: string) => {
+    if (fileName === tarFilePath) return true;
+    if (fileName === '.DS_Store') return true;
+    if (
+      !includeNodeModules &&
+      (fileName.startsWith(`node_modules${path.sep}`) || fileName.includes(`${path.sep}node_modules${path.sep}`))
+    )
+      return true;
+    if (
+      !includePublic &&
+      (fileName.startsWith(`public${path.sep}`) || fileName.includes(`${path.sep}public${path.sep}`))
+    )
+      return true;
+    const isGit = fileName.startsWith(`.git${path.sep}`);
+    const isLocalScope = fileName.startsWith(`.bit${path.sep}`) || fileName.startsWith(`.git${path.sep}bit${path.sep}`);
+    if (excludeLocalScope && isLocalScope) return true;
+    if (isGit && !isLocalScope) return true;
+    return false;
+  };
+
+  const myPack = tarFS.pack('.', {
+    ignore,
+    finalize: false,
+    finish: packExamineResults,
+  });
+
+  return myPack;
+}
+
+async function _getEnvMeta(): Promise<DoctorMetaData> {
+  const env = {
+    nodeVersion: process.version,
+    runningTimestamp: runningTimeStamp || _getTimeStamp(),
+    platform: os.platform(),
+    bitVersion: getHarmonyVersion(),
+    npmVersion: await getNpmVersion(),
+    yarnVersion: await getYarnVersion(),
+    userDetails: _getUserDetails(),
+  };
+
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  return env;
+}
+
+function _getUserDetails(): string {
+  const name = globalConfig.getSync(CFG_USER_NAME_KEY) || '';
+  const email = globalConfig.getSync(CFG_USER_EMAIL_KEY) || '';
+  return `${name}<${email}>`;
+}
+
+async function _getDebugLogAsBuffer(): Promise<Buffer | null | undefined> {
+  const exists = await fs.pathExists(DEBUG_LOG);
+  if (!exists) return null;
+  const log = await fs.readFile(DEBUG_LOG, 'utf-8');
+  const logWithoutChalk = removeChalkCharacters(log) as string;
+  return Buffer.from(logWithoutChalk);
+}
+
+async function _getConsumerInfo(): Promise<ConsumerInfo | null | undefined> {
+  const consumerInfo = await getConsumerInfo(process.cwd());
+  return consumerInfo;
+}
+
+function _getBitMap(workspaceDir): Buffer | null | undefined {
+  return BitMap.loadRawSync(workspaceDir);
+}

package/esm.mjs

@@ -0,0 +1,6 @@
+// eslint-disable-next-line import/no-unresolved
+import cjsModule from './index.js';
+
+export const DoctorAspect = cjsModule.DoctorAspect;
+
+export default cjsModule;

package/exceptions/diagnosis-not-found.ts

@@ -0,0 +1,8 @@
+import { BitError } from '@teambit/bit-error';
+import chalk from 'chalk';
+
+export class DiagnosisNotFound extends BitError {
+  constructor(public diagnosisName: string) {
+    super(`error: diagnosis ${chalk.bold(diagnosisName)} not found`);
+  }
+}

package/exceptions/missing-diagnosis-name.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+
+export class MissingDiagnosisName extends BitError {
+  constructor() {
+    super('error: please provide a diagnosis name');
+  }
+}

package/index.ts

@@ -0,0 +1,7 @@
+import { DoctorAspect } from './doctor.aspect';
+
+export type { DoctorMain } from './doctor.main.runtime';
+export { DiagnosisNotFound } from './exceptions/diagnosis-not-found';
+export { DIAGNOSIS_NAME_VALIDATE_GIT_EXEC } from './core-diagnoses/validate-git-exec';
+export default DoctorAspect;
+export { DoctorAspect };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@teambit/doctor",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "componentId": {
+    "name": "doctor",
+    "version": "0.0.1",
+    "scope": "teambit.harmony"
+  },
+  "dependencies": {
+    "chalk": "2.4.2",
+    "table": "5.4.6",
+    "fs-extra": "10.0.0",
+    "tar-fs": "2.1.1",
+    "tar-stream": "2.2.0",
+    "glob": "7.1.6",
+    "lodash": "4.17.21",
+    "semver": "7.5.2",
+    "execa": "2.1.0",
+    "core-js": "^3.0.0",
+    "@babel/runtime": "7.20.0",
+    "@teambit/harmony": "0.4.6",
+    "@teambit/scope.modules.find-scope-path": "0.0.1",
+    "@teambit/component-id": "1.2.0",
+    "@teambit/bvm.list": "0.1.13",
+    "@teambit/bit-error": "0.0.404",
+    "@teambit/cli": "0.0.895"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "9.0.7",
+    "@types/lodash": "4.14.165",
+    "@types/semver": "7.3.4",
+    "@types/node": "12.20.4",
+    "@types/react": "^17.0.8",
+    "@types/react-dom": "^17.0.5",
+    "@types/jest": "^26.0.0",
+    "@types/testing-library__jest-dom": "5.9.5"
+  },
+  "peerDependencies": {
+    "@teambit/legacy": "1.0.716",
+    "react": "^16.8.0 || ^17.0.0",
+    "react-dom": "^16.8.0 || ^17.0.0"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "optionalDependencies": {},
+  "peerDependenciesMeta": {},
+  "exports": {
+    "node": {
+      "require": "./dist/index.js",
+      "import": "./dist/esm.mjs"
+    },
+    "default": "./dist/index.js"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,45 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "ES2022",
+      "DOM",
+      "DOM.Iterable",
+      "ScriptHost"
+    ],
+    "target": "es2015",
+    "module": "CommonJS",
+    "jsx": "react",
+    "allowJs": true,
+    "composite": true,
+    "declaration": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "outDir": "dist",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "rootDir": ".",
+    "resolveJsonModule": true,
+    "emitDeclarationOnly": true,
+    "emitDecoratorMetadata": true,
+    "allowSyntheticDefaultImports": true,
+    "strictPropertyInitialization": false,
+    "strict": true,
+    "noImplicitAny": false,
+    "preserveConstEnums": true
+  },
+  "exclude": [
+    "artifacts",
+    "public",
+    "dist",
+    "esm.mjs",
+    "node_modules",
+    "package.json",
+    "**/*.cjs"
+  ],
+  "include": [
+    "**/*",
+    "**/*.json"
+  ],
+  "references": []
+}