@astryxdesign/cli 0.7.2-canary.db3a2e7 → 0.7.2-canary.e26723d

package/foundation/discovery/module-exports.test.mjs

@@ -0,0 +1,172 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Static reads of a module's exports, without running it: the file that
+ * declares an export, and an exported object literal as plain data.
+ */
+
+import {afterEach, beforeEach, describe, expect, it} from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {moduleExportSource, staticExportObject} from './module-exports.mjs';
+
+/** @type {string} */
+let dir;
+
+beforeEach(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-export-field-'));
+});
+
+afterEach(() => {
+  fs.rmSync(dir, {recursive: true, force: true});
+});
+
+/**
+ * @param {string} file
+ * @param {string} source
+ * @returns {string}
+ */
+function write(file, source) {
+  const filePath = path.join(dir, file);
+  fs.writeFileSync(filePath, source);
+  return filePath;
+}
+
+const DOC_EXPORTS = ['default', 'docs'];
+
+describe('staticExportObject', () => {
+  it('reads a default-exported object literal as plain data', () => {
+    const file = write(
+      'A.doc.mjs',
+      "export default {type: 'component', name: 'AcmeCarousel', order: 2, hidden: false, extra: null};\n",
+    );
+    expect(staticExportObject(file, DOC_EXPORTS)).toEqual({
+      type: 'component',
+      name: 'AcmeCarousel',
+      order: 2,
+      hidden: false,
+      extra: null,
+    });
+  });
+
+  it('reads a named export, an export list, and the first export it looks for', () => {
+    const named = write(
+      'B.doc.mjs',
+      "/** @type {object} */\nexport const docs = {\n  name: 'AcmeCarousel',\n};\n",
+    );
+    const both = write(
+      'C.doc.mjs',
+      "export const docs = {name: 'Legacy'};\nexport default {name: 'Stamped'};\n",
+    );
+    const list = write(
+      'E.doc.mjs',
+      "const local = {name: 'AcmeCarousel'};\nexport {local as docs};\n",
+    );
+    expect(staticExportObject(named, DOC_EXPORTS)?.name).toBe('AcmeCarousel');
+    expect(staticExportObject(both, DOC_EXPORTS)?.name).toBe('Stamped');
+    expect(staticExportObject(list, DOC_EXPORTS)?.name).toBe('AcmeCarousel');
+  });
+
+  it('follows top-level bindings through TypeScript wrappers, at any depth', () => {
+    const file = write(
+      'D.doc.ts',
+      [
+        "const slide = {name: 'AcmeSlide', description: 'One slide.'} as const;",
+        "const doc = {name: 'AcmeCarousel', components: [slide, {name: 'AcmeDots', description: 'Dots.'}]} satisfies {name: string};",
+        'export default doc;',
+        '',
+      ].join('\n'),
+    );
+    expect(staticExportObject(file, DOC_EXPORTS)).toEqual({
+      name: 'AcmeCarousel',
+      components: [
+        {name: 'AcmeSlide', description: 'One slide.'},
+        {name: 'AcmeDots', description: 'Dots.'},
+      ],
+    });
+  });
+
+  it('leaves out what it cannot read without running the module', () => {
+    const file = write(
+      'F.doc.mjs',
+      [
+        "const prefix = 'Acme';",
+        'const shared = {group: "Media"};',
+        'export default {',
+        '  // A computed string, a call and a spread: none is read.',
+        '  name: `${prefix}Carousel`,',
+        '  usage: makeUsage(),',
+        "  group: 'Overridden',",
+        '  ...shared,',
+        "  category: 'Media',",
+        "  components: [...more, {name: 'AcmeSlide'}],",
+        '};',
+        '',
+      ].join('\n'),
+    );
+    expect(staticExportObject(file, DOC_EXPORTS)).toEqual({
+      category: 'Media',
+      components: [{name: 'AcmeSlide'}],
+    });
+  });
+
+  it('answers null when there is no exported object', () => {
+    const files = [
+      write(
+        'G.doc.mjs',
+        "export const docs = {name: 'Legacy'};\nexport default makeDoc();\n",
+      ),
+      write('H.doc.mjs', 'export default {name: '),
+      write('I.doc.mjs', "export const other = {name: 'AcmeCarousel'};\n"),
+      write('J.doc.mjs', "export default ['AcmeCarousel'];\n"),
+    ];
+    for (const file of files) {
+      expect(staticExportObject(file, DOC_EXPORTS)).toBeNull();
+    }
+  });
+});
+
+describe('moduleExportSource', () => {
+  it('names the file that declares an export, following local re-exports', () => {
+    const impl = write(
+      'impl.tsx',
+      'export function AcmeSlide() { return null; }\n',
+    );
+    const barrel = write(
+      'index.ts',
+      "export {AcmeSlide} from './impl';\nexport * from './dots';\nexport function AcmeCarousel() { return null; }\n",
+    );
+    const dots = write('dots.tsx', 'export const AcmeDots = () => null;\n');
+    expect(moduleExportSource(barrel, 'AcmeSlide')).toBe(impl);
+    expect(moduleExportSource(barrel, 'AcmeDots')).toBe(dots);
+    expect(moduleExportSource(barrel, 'AcmeCarousel')).toBe(barrel);
+    expect(moduleExportSource(barrel, 'AcmeMissing')).toBeNull();
+  });
+
+  it('does not follow a re-export written in a comment', () => {
+    write('legacy.tsx', 'export function AcmeTab() { return null; }\n');
+    const barrel = write(
+      'tabs.ts',
+      "// export * from './legacy';\nexport function AcmeTabs() { return null; }\n",
+    );
+    expect(moduleExportSource(barrel, 'AcmeTab')).toBeNull();
+  });
+
+  it('does not count a type-only export', () => {
+    const file = write('types.ts', 'export type AcmeShape = {id: string};\n');
+    expect(moduleExportSource(file, 'AcmeShape')).toBeNull();
+  });
+
+  it('sees a file npm replaced with one of the same size and mtime', () => {
+    // npm stamps every installed file with one mtime and writes new files.
+    const npmTime = new Date('1985-10-26T08:15:00Z');
+    const file = write('Panel.tsx', 'export function AcmePanel() {}\n');
+    fs.utimesSync(file, npmTime, npmTime);
+    expect(moduleExportSource(file, 'AcmePanel')).toBe(file);
+    const next = write('Panel.next.tsx', 'export function AcmePanol() {}\n');
+    fs.utimesSync(next, npmTime, npmTime);
+    fs.renameSync(next, file);
+    expect(moduleExportSource(file, 'AcmePanel')).toBeNull();
+  });
+});

package/foundation/discovery/package-tsconfig.d.mts

@@ -0,0 +1,14 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in foundation/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * @param {any} ts the project's own `typescript`
+ * @param {string} packageDir
+ * @param {string[]} sources the files to read
+ * @returns {{options: any, declarations: string[], error?: string}}
+ */
+export function readPackageTsconfig(ts: any, packageDir: string, sources: string[]): {
+    options: any;
+    declarations: string[];
+    error?: string;
+};

package/foundation/discovery/package-tsconfig.mjs

@@ -0,0 +1,228 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Read a package's TypeScript project the way `tsc` reads it, so a
+ * check that reads the package's types with its own compiler sees what the
+ * package compiles against.
+ *
+ * - The config is the nearest `tsconfig.json`: the package's own, or a
+ *   monorepo's root config for a local package. An app's config above an
+ *   installed package (one below `node_modules`) is not the package's, and is
+ *   not read.
+ * - A solution-style config (`"files": []` with `references`) lends the
+ *   referenced config, at any depth, that includes the files to read.
+ * - The declaration files the config includes, included files that declare
+ *   globals or augment a module, and included scripts (no import or export)
+ *   join the files to read, so ambient types resolve as `tsc` resolves them.
+ * - Without a config, defaults read TSX the way bundlers do. A config with
+ *   errors is reported, never read as defaults.
+ *
+ * @input The project's own `typescript`, the package directory, and the
+ *   source files to read.
+ * @output Compiler options, the declaration files to add, and the config's
+ *   error, if any.
+ * @position Foundation discovery, used by the documented-props comparison.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/**
+ * Whether a file the config includes declares types every file sees: a
+ * declaration file, a file that declares globals or augments a module, or a
+ * script (a `.ts` file that TypeScript reads as no module).
+ * @param {any} ts
+ * @param {string} file
+ */
+function isAmbient(ts, file) {
+  if (/\.d\.[cm]?ts$/.test(file)) return true;
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch {
+    return false;
+  }
+  if (/\bdeclare\s+(?:global|module)\b/.test(text)) return true;
+  if (!/\.tsx?$/.test(file)) return false;
+  // Without the words, no module; with them, TypeScript decides.
+  return (
+    !/\b(?:import|export)\b/.test(text) ||
+    !ts.isExternalModule(
+      ts.createSourceFile(file, text, ts.ScriptTarget.Latest),
+    )
+  );
+}
+
+/**
+ * Read a config's `files` entries as `tsc` does, and report the first it
+ * cannot find. TypeScript itself substitutes `${configDir}` (on a version
+ * that has it), resolves each entry against the config that writes it, and
+ * tries the TypeScript extensions for one written without its own, so this
+ * cannot drift from `tsc`. The parsed file names then hold the files found.
+ * A file the `include` matched that is gone by the time it is read was
+ * another process's, and is not checked here.
+ * @param {any} ts
+ * @param {any} raw the config's JSON
+ * @param {string} configPath
+ * @param {any} config the parsed config, whose file names are updated
+ * @returns {string | null} the message `tsc` gives for the first entry it
+ *   cannot find (TS6053, or TS6231 for a folder)
+ */
+function readFilesEntries(ts, raw, configPath, config) {
+  const literal = ts.parseJsonConfigFileContent(
+    raw,
+    {...ts.sys, readDirectory: () => []},
+    path.dirname(configPath),
+    undefined,
+    configPath,
+  ).fileNames;
+  if (literal.length === 0 || typeof ts.createProgram !== 'function') {
+    return null;
+  }
+  // Only the entries themselves: no library, no types, no imports.
+  const program = ts.createProgram({
+    rootNames: literal,
+    options: {
+      ...config.options,
+      noLib: true,
+      noResolve: true,
+      types: [],
+      noEmit: true,
+    },
+  });
+  const missing = program
+    .getOptionsDiagnostics()
+    .find(/** @param {any} d */ d => d.code === 6053 || d.code === 6231);
+  if (missing) {
+    const text = missing.messageText;
+    return typeof text === 'string' ? text : text.messageText;
+  }
+  const entries = new Set(
+    literal.map(/** @param {string} f */ f => path.resolve(f)),
+  );
+  config.fileNames = [
+    ...config.fileNames.filter(
+      /** @param {string} f */ f => !entries.has(path.resolve(f)),
+    ),
+    ...program.getSourceFiles().map(/** @param {any} sf */ sf => sf.fileName),
+  ];
+  return null;
+}
+
+/**
+ * @param {any} ts the project's own `typescript`
+ * @param {string} packageDir
+ * @param {string[]} sources the files to read
+ * @returns {{options: any, declarations: string[], error?: string}}
+ */
+export function readPackageTsconfig(ts, packageDir, sources) {
+  const defaults = {
+    jsx: ts.JsxEmit.ReactJSX,
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    strict: true,
+    allowJs: true,
+    esModuleInterop: true,
+    resolveJsonModule: true,
+    allowImportingTsExtensions: true,
+  };
+  /** @type {string | undefined} */
+  let error;
+  /** @type {(configPath: string) => any} */
+  const parse = configPath => {
+    const read = ts.readConfigFile(configPath, ts.sys.readFile);
+    const config = read.error
+      ? {errors: [read.error], fileNames: [], options: {}}
+      : ts.parseJsonConfigFileContent(
+          read.config,
+          ts.sys,
+          path.dirname(configPath),
+          undefined,
+          configPath,
+        );
+    // "No inputs were found" is how a solution-style config reads.
+    const problem = config.errors.find(
+      /** @param {any} d */ d => d.code !== 18003,
+    );
+    const where = path.relative(packageDir, configPath);
+    if (problem) {
+      config.error = `${where}: ${ts.flattenDiagnosticMessageText(problem.messageText, ' ')}`;
+    } else if (!read.error) {
+      const missing = readFilesEntries(ts, read.config, configPath, config);
+      if (missing) {
+        // Paths read from the package, as the config's other errors are.
+        const dir = path.dirname(configPath).split(path.sep).join('/');
+        const rel = path.relative(packageDir, path.dirname(configPath));
+        config.error = `${where}: ${missing
+          .split(`${dir}/`)
+          .join(rel ? `${rel.split(path.sep).join('/')}/` : '')}`;
+      }
+    }
+    return config;
+  };
+  /** @type {any} */
+  let parsed;
+  try {
+    const found = ts.findConfigFile(
+      packageDir,
+      ts.sys.fileExists,
+      'tsconfig.json',
+    );
+    // A config above the package is an app's when the package is installed
+    // below it (`node_modules`), and the package's own otherwise (a
+    // monorepo's root config, as `tsc` reads it).
+    const installed =
+      found &&
+      path
+        .relative(path.dirname(found), packageDir)
+        .split(path.sep)
+        .includes('node_modules');
+    parsed = found && !installed ? parse(found) : null;
+    const own = new Set(sources.map(file => path.resolve(file)));
+    /** @type {(config: any) => boolean} */
+    const includes = config =>
+      config.fileNames.some(
+        /** @param {string} file */ file => own.has(path.resolve(file)),
+      );
+    // Every reference, at any depth, each config once (a cycle ends). One
+    // that is missing or doesn't parse is the project's error when no config
+    // includes the sources, as `tsc` reports it.
+    const visited = new Set(found ? [path.resolve(found)] : []);
+    /** @type {any} */
+    let broken = null;
+    /** @type {(config: any) => any} */
+    const including = config => {
+      if (includes(config)) return config;
+      for (const ref of config.projectReferences ?? []) {
+        const next = path.resolve(ts.resolveProjectReferencePath(ref));
+        if (visited.has(next)) continue;
+        visited.add(next);
+        const referenced = parse(next);
+        if (referenced.error) broken ??= referenced;
+        const hit = including(referenced);
+        if (hit) return hit;
+      }
+      return null;
+    };
+    if (parsed) parsed = including(parsed) ?? broken ?? parsed;
+  } catch {
+    parsed = null;
+  }
+  error = parsed?.error;
+  const options = parsed ? {...parsed.options} : defaults;
+  if (options.jsx == null) options.jsx = defaults.jsx;
+  return {
+    options: {
+      ...options,
+      noEmit: true,
+      skipLibCheck: true,
+      incremental: false,
+      composite: false,
+    },
+    ...(error ? {error} : {}),
+    declarations: (parsed?.fileNames ?? []).filter(
+      /** @param {string} file */ file => isAmbient(ts, file),
+    ),
+  };
+}

package/foundation/discovery/package-tsconfig.test.mjs

@@ -0,0 +1,210 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file readPackageTsconfig(): the package's own config, a solution-style
+ * config's references, a monorepo root's config for a local package but not
+ * an app's above an installed one, ambient declaration files, and a config
+ * with errors.
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {createRequire} from 'node:module';
+import {afterEach, beforeEach, describe, expect, it} from 'vitest';
+import {readPackageTsconfig} from './package-tsconfig.mjs';
+
+const require = createRequire(import.meta.url);
+const ts = require('typescript');
+
+/** @type {string} */
+let root;
+
+beforeEach(() => {
+  root = fs.realpathSync(
+    fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-tsconfig-')),
+  );
+});
+
+afterEach(() => {
+  fs.rmSync(root, {recursive: true, force: true});
+});
+
+/**
+ * @param {string} rel
+ * @param {string | object} content
+ */
+function write(rel, content) {
+  const file = path.join(root, rel);
+  fs.mkdirSync(path.dirname(file), {recursive: true});
+  fs.writeFileSync(
+    file,
+    typeof content === 'string' ? content : JSON.stringify(content),
+  );
+  return file;
+}
+
+const OPTIONS = {strict: true, jsx: 'react-jsx', paths: {'@/*': ['./src/*']}};
+
+describe('readPackageTsconfig', () => {
+  it('reads defaults without a config, and the config the package has, with the declaration files it includes', () => {
+    const source = write('src/Button.tsx', 'export {};\n');
+    const defaults = readPackageTsconfig(ts, root, [source]);
+    expect(defaults.options).toMatchObject({
+      jsx: ts.JsxEmit.ReactJSX,
+      strict: true,
+      noEmit: true,
+    });
+    expect(defaults.declarations).toEqual([]);
+    expect(defaults.error).toBeUndefined();
+
+    write('tsconfig.json', {
+      compilerOptions: OPTIONS,
+      include: ['src', 'types'],
+    });
+    const ambient = write('types/ambient.d.ts', 'interface A {}\n');
+    const global = write('src/global.ts', 'declare global {}\nexport {};\n');
+    // A script (no import or export) declares globals too, an `export`
+    // inside its namespace included.
+    const script = write('types/props.ts', 'interface ScriptProps {}\n');
+    const namespace = write(
+      'types/acme.ts',
+      'declare namespace Acme {\n  export interface Props {}\n}\n',
+    );
+    write('src/module.ts', 'export interface ModuleProps {}\n');
+
+    const own = readPackageTsconfig(ts, root, [source]);
+
+    expect(own.options.paths).toEqual(OPTIONS.paths);
+    expect(own.declarations.sort()).toEqual(
+      [global, ambient, script, namespace].sort(),
+    );
+  });
+
+  it("follows a solution-style config's references, at any depth and through a cycle, to the config that includes the sources", () => {
+    const source = write('src/Button.tsx', 'export {};\n');
+    const chain = [
+      'tsconfig.json',
+      'l1.json',
+      'l2.json',
+      'l3.json',
+      'l4.json',
+      'l5.json',
+    ];
+    chain.forEach((file, i) =>
+      write(file, {
+        files: [],
+        // Each level also refers back to the root, a cycle tsc rejects but
+        // the walk must not loop on.
+        references: [
+          {path: `./${chain[i + 1] ?? 'app.json'}`},
+          {path: './tsconfig.json'},
+        ],
+      }),
+    );
+    write('app.json', {compilerOptions: OPTIONS, include: ['src']});
+
+    const project = readPackageTsconfig(ts, root, [source]);
+
+    expect(project.error).toBeUndefined();
+    expect(project.options.paths).toEqual(OPTIONS.paths);
+
+    // A reference that is missing or doesn't parse, when no config includes
+    // the sources, is the project's error, as `tsc` reports it.
+    write('tsconfig.json', {files: [], references: [{path: './gone.json'}]});
+    expect(readPackageTsconfig(ts, root, [source]).error).toMatch(
+      /^gone\.json: .*gone\.json/,
+    );
+    write('broken.json', '{"compilerOptions": ');
+    write('tsconfig.json', {files: [], references: [{path: './broken.json'}]});
+    expect(readPackageTsconfig(ts, root, [source]).error).toMatch(
+      /^broken\.json: /,
+    );
+  });
+
+  it("reads a monorepo root's config for a local package, and not an app's config for a package installed below it", () => {
+    write('tsconfig.json', {compilerOptions: OPTIONS});
+    const local = path.join(root, 'packages', 'local');
+    const installed = path.join(root, 'node_modules', '@acme', 'widgets');
+    const localSource = write('packages/local/src/Button.tsx', 'export {};\n');
+    const installedSource = write(
+      'node_modules/@acme/widgets/src/Button.tsx',
+      'export {};\n',
+    );
+
+    expect(readPackageTsconfig(ts, local, [localSource]).options.paths).toEqual(
+      OPTIONS.paths,
+    );
+    expect(
+      readPackageTsconfig(ts, installed, [installedSource]).options.paths,
+    ).toBeUndefined();
+  });
+
+  it('reports a config with errors instead of reading defaults', () => {
+    const source = write('src/Button.tsx', 'export {};\n');
+    write('tsconfig.json', {files: ['src/Button.tsx', 'src/missing.ts']});
+    expect(readPackageTsconfig(ts, root, [source]).error).toMatch(
+      /^tsconfig\.json: .*src\/missing\.ts.* not found/,
+    );
+
+    write('tsconfig.json', {extends: './missing-base.json'});
+    expect(readPackageTsconfig(ts, root, [source]).error).toMatch(
+      /^tsconfig\.json: .*missing-base\.json/,
+    );
+
+    write('tsconfig.json', '{"compilerOptions": ');
+    expect(readPackageTsconfig(ts, root, [source]).error).toMatch(
+      /^tsconfig\.json: /,
+    );
+  });
+
+  it('reads each `files` entry as `tsc` finds it', () => {
+    const source = write('src/Button.tsx', 'export {};\n');
+    write('src/Card.ts', 'export {};\n');
+    write('types/globals.ts', 'interface AcmeGlobal { tone?: string }\n');
+    write('configs/base.json', {files: ['${configDir}/src/Button.tsx']});
+    /** @type {(config: object) => any} */
+    const read = config => {
+      write('tsconfig.json', {compilerOptions: OPTIONS, ...config});
+      return readPackageTsconfig(ts, root, [source]);
+    };
+
+    // `${configDir}`, written in the package's config or in a shared base it
+    // extends, and an entry without its extension compile with `tsc -p`.
+    expect(
+      read({files: ['${configDir}/src/Button.tsx']}).error,
+    ).toBeUndefined();
+    expect(read({extends: './configs/base.json'}).error).toBeUndefined();
+    const bare = read({files: ['src/Button', 'src/Card', 'types/globals']});
+    expect(bare.error).toBeUndefined();
+    expect(bare.declarations).toEqual([path.join(root, 'types', 'globals.ts')]);
+
+    // An entry `tsc` can't find is an error: a missing file (TS6053), and a
+    // folder (TS6231).
+    expect(read({files: ['src/Button.tsx', 'src/gone.ts']}).error).toMatch(
+      /^tsconfig\.json: File 'src\/gone\.ts' not found\.$/,
+    );
+    expect(read({files: ['src']}).error).toMatch(
+      /^tsconfig\.json: Could not resolve the path 'src' with the extensions/,
+    );
+  });
+
+  it('reports only a missing `files` entry, not a file the `include` matched that is gone by the time it is read', () => {
+    const source = write('src/Button.tsx', 'export {};\n');
+    write('tsconfig.json', {compilerOptions: OPTIONS, include: ['src']});
+    // A file another process writes and removes while the config is read.
+    const gone = path.join(root, 'src', 'gone.ts');
+    const racing = {
+      ...ts,
+      sys: {
+        ...ts.sys,
+        readDirectory: (/** @type {any[]} */ ...args) => [
+          ...ts.sys.readDirectory(...args),
+          gone,
+        ],
+      },
+    };
+
+    expect(readPackageTsconfig(racing, root, [source]).error).toBeUndefined();
+  });
+});

package/foundation/discovery/project-typescript.d.mts

@@ -0,0 +1,23 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in foundation/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * Resolve the project's own `typescript`, trying each directory in order.
+ * @param {Array<string | null | undefined>} dirs
+ * @returns {{ts: any, version: string} | {ts: null, version: string} | null}
+ *   `ts: null` when a TypeScript is installed but has no `createProgram`
+ */
+export function resolveProjectTypeScript(dirs: Array<string | null | undefined>): {
+    ts: any;
+    version: string;
+} | {
+    ts: null;
+    version: string;
+} | null;
+/**
+ * Why a check that needs the compiler did not run, when the TypeScript
+ * installed has no JavaScript compiler API.
+ * @param {string} version
+ * @param {string} outcome what was not done, such as `docs were not checked`
+ */
+export function unusableTypeScriptReason(version: string, outcome: string): string;