@teambit/typescript 1.0.108 → 1.0.110

package/typescript.compiler.ts

@@ -1,286 +0,0 @@
-import { BuildContext, BuiltTaskResult, ComponentResult } from '@teambit/builder';
-import { Compiler, TranspileFileParams, TranspileFileOutput } from '@teambit/compiler';
-import { Network } from '@teambit/isolator';
-import { Logger } from '@teambit/logger';
-import fs from 'fs-extra';
-import path from 'path';
-import ts from 'typescript';
-import { BitError } from '@teambit/bit-error';
-import { TypeScriptCompilerOptions } from './compiler-options';
-
-export class TypescriptCompiler implements Compiler {
-  distDir: string;
-  distGlobPatterns: string[];
-  shouldCopyNonSupportedFiles: boolean;
-  artifactName: string;
-  constructor(
-    readonly id: string,
-    private logger: Logger,
-    private options: TypeScriptCompilerOptions,
-    private tsModule: typeof ts
-  ) {
-    this.distDir = options.distDir || 'dist';
-    this.distGlobPatterns = options.distGlobPatterns || [`${this.distDir}/**`, `!${this.distDir}/tsconfig.tsbuildinfo`];
-    this.shouldCopyNonSupportedFiles =
-      typeof options.shouldCopyNonSupportedFiles === 'boolean' ? options.shouldCopyNonSupportedFiles : true;
-    this.artifactName = options.artifactName || 'dist';
-    this.options.tsconfig ||= {};
-    this.options.tsconfig.compilerOptions ||= {};
-    // mutate the outDir, otherwise, on capsules, the dists might be written to a different directory and make confusion
-    this.options.tsconfig.compilerOptions.outDir = this.distDir;
-  }
-
-  displayName = 'TypeScript';
-  deleteDistDir = false;
-
-  displayConfig() {
-    return this.stringifyTsconfig(this.options.tsconfig);
-  }
-
-  getDistDir() {
-    return this.distDir;
-  }
-
-  /**
-   * compile one file on the workspace
-   */
-  transpileFile(fileContent: string, options: TranspileFileParams): TranspileFileOutput {
-    if (!this.isFileSupported(options.filePath)) {
-      return null; // file is not supported
-    }
-    const compilerOptionsFromTsconfig = this.tsModule.convertCompilerOptionsFromJson(
-      this.options.tsconfig.compilerOptions,
-      '.'
-    );
-    if (compilerOptionsFromTsconfig.errors.length) {
-      // :TODO @david replace to a more concrete error type and put in 'exceptions' directory here.
-      const formattedErrors = this.tsModule.formatDiagnosticsWithColorAndContext(
-        compilerOptionsFromTsconfig.errors,
-        this.getFormatDiagnosticsHost()
-      );
-      throw new Error(`failed parsing the tsconfig.json.\n${formattedErrors}`);
-    }
-
-    const compilerOptions = compilerOptionsFromTsconfig.options;
-    compilerOptions.sourceRoot = options.componentDir;
-    compilerOptions.rootDir = '.';
-    const result = this.tsModule.transpileModule(fileContent, {
-      compilerOptions,
-      fileName: options.filePath,
-      reportDiagnostics: true,
-    });
-
-    if (result.diagnostics && result.diagnostics.length) {
-      const formatHost = this.getFormatDiagnosticsHost();
-      const error = this.tsModule.formatDiagnosticsWithColorAndContext(result.diagnostics, formatHost);
-
-      // :TODO @david please replace to a more concrete error type and put in 'exceptions' directory here.
-      throw new Error(error);
-    }
-
-    const outputPath = this.replaceFileExtToJs(options.filePath);
-    const outputFiles = [{ outputText: result.outputText, outputPath }];
-    if (result.sourceMapText) {
-      outputFiles.push({
-        outputText: result.sourceMapText,
-        outputPath: `${outputPath}.map`,
-      });
-    }
-    return outputFiles;
-  }
-
-  async preBuild(context: BuildContext) {
-    const capsules = context.capsuleNetwork.seedersCapsules;
-    const capsuleDirs = capsules.map((capsule) => capsule.path);
-    await this.writeTsConfig(capsuleDirs);
-    await this.writeTypes(capsuleDirs);
-    await this.writeNpmIgnore(capsuleDirs);
-  }
-
-  /**
-   * compile multiple components on the capsules
-   */
-  async build(context: BuildContext): Promise<BuiltTaskResult> {
-    const componentsResults = await this.runTscBuild(context.capsuleNetwork);
-
-    return {
-      artifacts: this.getArtifactDefinition(),
-      componentsResults,
-    };
-  }
-
-  getArtifactDefinition() {
-    return [
-      {
-        generatedBy: this.id,
-        name: this.artifactName,
-        globPatterns: this.distGlobPatterns,
-      },
-    ];
-  }
-
-  /**
-   * given a source file, return its parallel in the dists. e.g. index.ts => dist/index.js
-   */
-  getDistPathBySrcPath(srcPath: string) {
-    const fileWithJSExtIfNeeded = this.replaceFileExtToJs(srcPath);
-    return path.join(this.distDir, fileWithJSExtIfNeeded);
-  }
-
-  /**
-   * whether typescript is able to compile the given path
-   */
-  isFileSupported(filePath: string): boolean {
-    const isJsAndCompile = !!this.options.compileJs && filePath.endsWith('.js');
-    const isJsxAndCompile = !!this.options.compileJsx && filePath.endsWith('.jsx');
-    return (
-      (filePath.endsWith('.ts') || filePath.endsWith('.tsx') || isJsAndCompile || isJsxAndCompile) &&
-      !filePath.endsWith('.d.ts')
-    );
-  }
-
-  /**
-   * we have two options here:
-   * 1. pass all capsules-dir at the second parameter of createSolutionBuilder and then no
-   * need to write the main tsconfig.json with all the references.
-   * 2. write main tsconfig.json and pass the capsules root-dir.
-   * we went with option #2 because it'll be easier for users to go to the capsule-root and run
-   * `tsc --build` to debug issues.
-   */
-  private async runTscBuild(network: Network): Promise<ComponentResult[]> {
-    const rootDir = network.capsulesRootDir;
-    const capsules = await network.getCapsulesToCompile();
-    if (!capsules.length) {
-      return [];
-    }
-    const capsuleDirs = capsules.getAllCapsuleDirs();
-    const formatHost = {
-      getCanonicalFileName: (p) => p,
-      getCurrentDirectory: () => '', // it helps to get the files with absolute paths
-      getNewLine: () => this.tsModule.sys.newLine,
-    };
-    const componentsResults: ComponentResult[] = [];
-    let currentComponentResult: Partial<ComponentResult> = { errors: [] };
-    const reportDiagnostic = (diagnostic: ts.Diagnostic) => {
-      const errorStr = process.stdout.isTTY
-        ? this.tsModule.formatDiagnosticsWithColorAndContext([diagnostic], formatHost)
-        : this.tsModule.formatDiagnostic(diagnostic, formatHost);
-      if (!diagnostic.file) {
-        // the error is general and not related to a specific file. e.g. tsconfig is missing.
-        throw new BitError(errorStr);
-      }
-      this.logger.consoleFailure(errorStr);
-      if (!currentComponentResult.component || !currentComponentResult.errors) {
-        throw new Error(`currentComponentResult is not defined yet for ${diagnostic.file}`);
-      }
-      currentComponentResult.errors.push(errorStr);
-    };
-    // this only works when `verbose` is `true` in the `ts.createSolutionBuilder` function.
-    const reportSolutionBuilderStatus = (diag: ts.Diagnostic) => {
-      const msg = diag.messageText as string;
-      this.logger.debug(msg);
-    };
-    const errorCounter = (errorCount: number) => {
-      this.logger.info(`total error found: ${errorCount}`);
-    };
-    const host = this.tsModule.createSolutionBuilderHost(
-      undefined,
-      undefined,
-      reportDiagnostic,
-      reportSolutionBuilderStatus,
-      errorCounter
-    );
-    await this.writeProjectReferencesTsConfig(rootDir, capsuleDirs);
-    const solutionBuilder = this.tsModule.createSolutionBuilder(host, [rootDir], { verbose: true });
-    let nextProject;
-    const longProcessLogger = this.logger.createLongProcessLogger('compile typescript components', capsules.length);
-    // eslint-disable-next-line no-cond-assign
-    while ((nextProject = solutionBuilder.getNextInvalidatedProject())) {
-      // regex to make sure it will work correctly for both linux and windows
-      // it replaces both /tsconfig.json and \tsocnfig.json
-      const capsulePath = nextProject.project.replace(/[/\\]tsconfig.json/, '');
-      const currentComponentId = capsules.getIdByPathInCapsule(capsulePath);
-      if (!currentComponentId) throw new Error(`unable to find component for ${capsulePath}`);
-      longProcessLogger.logProgress(currentComponentId.toString());
-      const capsule = capsules.getCapsule(currentComponentId);
-      if (!capsule) throw new Error(`unable to find capsule for ${currentComponentId.toString()}`);
-      currentComponentResult.component = capsule.component;
-      currentComponentResult.startTime = Date.now();
-      nextProject.done();
-      currentComponentResult.endTime = Date.now();
-      componentsResults.push({ ...currentComponentResult } as ComponentResult);
-      currentComponentResult = { errors: [] };
-    }
-    longProcessLogger.end();
-
-    return componentsResults;
-  }
-
-  private getFormatDiagnosticsHost(): ts.FormatDiagnosticsHost {
-    return {
-      getCanonicalFileName: (p) => p,
-      getCurrentDirectory: this.tsModule.sys.getCurrentDirectory,
-      getNewLine: () => this.tsModule.sys.newLine,
-    };
-  }
-
-  private async writeTypes(dirs: string[]) {
-    await Promise.all(
-      this.options.types.map(async (typePath) => {
-        const contents = await fs.readFile(typePath, 'utf8');
-        const filename = path.basename(typePath);
-
-        await Promise.all(
-          dirs.map(async (dir) => {
-            const filePath = path.join(dir, 'types', filename);
-            if (!(await fs.pathExists(filePath))) {
-              await fs.outputFile(filePath, contents);
-            }
-          })
-        );
-      })
-    );
-  }
-
-  /**
-   * when using project-references, typescript adds a file "tsconfig.tsbuildinfo" which is not
-   * needed for the package.
-   */
-  private async writeNpmIgnore(dirs: string[]) {
-    const NPM_IGNORE_FILE = '.npmignore';
-    await Promise.all(
-      dirs.map(async (dir) => {
-        const npmIgnorePath = path.join(dir, NPM_IGNORE_FILE);
-        const npmIgnoreEntriesStr = `\n${this.distDir}/tsconfig.tsbuildinfo\n`;
-        await fs.appendFile(npmIgnorePath, npmIgnoreEntriesStr);
-      })
-    );
-  }
-
-  private async writeProjectReferencesTsConfig(rootDir: string, projects: string[]) {
-    const files = [];
-    const references = projects.map((project) => ({ path: project }));
-    const tsconfig = { files, references };
-    const tsconfigStr = this.stringifyTsconfig(tsconfig);
-    await fs.writeFile(path.join(rootDir, 'tsconfig.json'), tsconfigStr);
-  }
-
-  private async writeTsConfig(dirs: string[]) {
-    const tsconfigStr = this.stringifyTsconfig(this.options.tsconfig);
-    await Promise.all(dirs.map((dir) => fs.writeFile(path.join(dir, 'tsconfig.json'), tsconfigStr)));
-  }
-
-  private stringifyTsconfig(tsconfig) {
-    return JSON.stringify(tsconfig, undefined, 2);
-  }
-
-  private replaceFileExtToJs(filePath: string): string {
-    if (!this.isFileSupported(filePath)) return filePath;
-    const fileExtension = path.extname(filePath);
-    return filePath.replace(new RegExp(`${fileExtension}$`), '.js'); // makes sure it's the last occurrence
-  }
-
-  version() {
-    return this.tsModule.version;
-  }
-}

package/typescript.extractor.ts

@@ -1,247 +0,0 @@
-import ts, { Node, SourceFile, SyntaxKind } from 'typescript';
-import { getTsconfig } from 'get-tsconfig';
-import { SchemaExtractor, SchemaExtractorOptions } from '@teambit/schema';
-import { TsserverClient } from '@teambit/ts-server';
-import type { Workspace } from '@teambit/workspace';
-import { ComponentDependency, DependencyResolverMain } from '@teambit/dependency-resolver';
-import { SchemaNode, APISchema, ModuleSchema, UnImplementedSchema } from '@teambit/semantics.entities.semantic-schema';
-import { Component } from '@teambit/component';
-import { AbstractVinyl } from '@teambit/legacy/dist/consumer/component/sources';
-import { EnvContext } from '@teambit/envs';
-import { Formatter } from '@teambit/formatter';
-import { Logger } from '@teambit/logger';
-import AspectLoaderAspect, { AspectLoaderMain, getCoreAspectPackageName } from '@teambit/aspect-loader';
-import { ScopeMain } from '@teambit/scope';
-import pMapSeries from 'p-map-series';
-import { compact, flatten } from 'lodash';
-import { TypescriptMain, SchemaTransformerSlot, APITransformerSlot } from './typescript.main.runtime';
-import { TransformerNotFound } from './exceptions';
-import { SchemaExtractorContext } from './schema-extractor-context';
-import { Identifier } from './identifier';
-import { IdentifierList } from './identifier-list';
-import { ExtractorOptions } from './extractor-options';
-import { TypescriptAspect } from './typescript.aspect';
-
-export class TypeScriptExtractor implements SchemaExtractor {
-  constructor(
-    private tsconfig: any,
-    private schemaTransformerSlot: SchemaTransformerSlot,
-    private apiTransformerSlot: APITransformerSlot,
-    private tsMain: TypescriptMain,
-    private rootTsserverPath: string,
-    private rootContextPath: string,
-    private depResolver: DependencyResolverMain,
-    private workspace: Workspace | undefined,
-    private scope: ScopeMain,
-    private aspectLoader: AspectLoaderMain,
-    private logger: Logger
-  ) {}
-
-  parseSourceFile(file: AbstractVinyl): SourceFile {
-    const sourceFile = ts.createSourceFile(
-      file.path,
-      file.contents.toString('utf8'),
-      ts.ScriptTarget.Latest,
-      true
-      /** don't pass the scriptKind, it'll be determined automatically by typescript by the filepath */
-    );
-    // leave this commented out, it's helpful when there are issues with ASTs. consider throwing in this case.
-    // console.log("sourceFile Errors", file.path, sourceFile.parseDiagnostics);
-    return sourceFile;
-  }
-
-  /**
-   * extract a component schema.
-   */
-  async extract(component: Component, options: SchemaExtractorOptions = {}): Promise<APISchema> {
-    // override the rootTsserverPath and rootContextPath if passed via options
-    if (options.tsserverPath) {
-      this.rootTsserverPath = options.tsserverPath;
-    }
-    if (options.contextPath) {
-      this.rootContextPath = options.contextPath;
-    }
-    const tsserver = await this.getTsServer();
-    const mainFile = component.mainFile;
-    const compatibleExts = ['.tsx', '.ts'];
-    const internalFiles = component.filesystem.files.filter(
-      (file) => compatibleExts.includes(file.extname) && file.path !== mainFile.path
-    );
-    const allFiles = [mainFile, ...internalFiles];
-
-    const context = await this.createContext(tsserver, component, options.formatter);
-
-    await pMapSeries(allFiles, async (file) => {
-      const ast = this.parseSourceFile(file);
-      const identifiers = await this.computeIdentifiers(ast, context); // compute for every file
-      const cacheKey = context.getIdentifierKeyForNode(ast);
-      context.setIdentifiers(cacheKey, new IdentifierList(identifiers));
-    });
-
-    const mainAst = this.parseSourceFile(mainFile);
-    const moduleSchema = (await this.computeSchema(mainAst, context)) as ModuleSchema;
-    moduleSchema.flatExportsRecursively();
-    const apiScheme = moduleSchema;
-    const internals = await this.computeInternalModules(context, internalFiles);
-
-    const location = context.getLocation(mainAst);
-
-    return new APISchema(location, apiScheme, internals, component.id as any);
-  }
-
-  async computeInternalModules(context: SchemaExtractorContext, internalFiles: AbstractVinyl[]) {
-    const internals = compact(
-      await Promise.all(
-        [...context.internalIdentifiers.entries()].map(async ([filePath]) => {
-          const file = internalFiles.find((internalFile) => internalFile.path === filePath);
-          if (!file) return undefined;
-          const fileAst = this.parseSourceFile(file);
-          const moduleSchema = (await this.computeSchema(fileAst, context)) as ModuleSchema;
-          moduleSchema.flatExportsRecursively();
-          return moduleSchema;
-        })
-      )
-    );
-    return internals;
-  }
-
-  dispose() {
-    if (!this.tsserver) return;
-    this.tsserver.killTsServer();
-  }
-
-  async computeIdentifiers(node: Node, context: SchemaExtractorContext) {
-    const transformer = this.getTransformer(node, context);
-    let identifiers: Identifier[] = [];
-    if (!transformer || !transformer.getIdentifiers) {
-      this.logger.debug(new TransformerNotFound(node, context.component, context.getLocation(node)).toString());
-    } else {
-      identifiers = await transformer.getIdentifiers(node, context);
-    }
-    return identifiers;
-  }
-
-  private async createContext(
-    tsserver: TsserverClient,
-    component: Component,
-    formatter?: Formatter
-  ): Promise<SchemaExtractorContext> {
-    const componentDeps = await this.getComponentDeps(component);
-    return new SchemaExtractorContext(
-      tsserver,
-      component,
-      this,
-      componentDeps,
-      this.rootContextPath,
-      this.workspace?.path || this.scope.path,
-      formatter
-    );
-  }
-
-  private async getComponentDeps(component: Component): Promise<ComponentDependency[]> {
-    const deps = await this.depResolver.getDependencies(component);
-    const componentDeps = deps.getComponentDependencies();
-    return componentDeps;
-  }
-
-  private tsserver: TsserverClient | undefined = undefined;
-
-  private async getTsServer() {
-    if (!this.tsserver) {
-      const tsserver = this.tsMain.getTsserverClient();
-      if (tsserver) {
-        this.tsserver = tsserver;
-        return tsserver;
-      }
-
-      this.tsserver = await this.tsMain.initTsserverClient(this.rootTsserverPath);
-      return this.tsserver;
-    }
-
-    return this.tsserver;
-  }
-
-  async computeSchema(node: Node, context: SchemaExtractorContext): Promise<SchemaNode> {
-    const transformer = this.getTransformer(node, context);
-
-    if (!transformer) {
-      return new UnImplementedSchema(context.getLocation(node), node.getText(), SyntaxKind[node.kind]);
-    }
-
-    const schemaNode = await transformer.transform(node, context);
-
-    return this.transformAPI(schemaNode, context);
-  }
-
-  async transformAPI(schema: SchemaNode, context: SchemaExtractorContext): Promise<SchemaNode> {
-    const apiTransformer = this.getAPITransformer(schema);
-    return apiTransformer ? apiTransformer.transform(schema, context) : schema;
-  }
-
-  async getComponentIDByPath(file: string) {
-    const coreAspectIds = this.aspectLoader.getCoreAspectIds();
-    const matchingCoreAspect = coreAspectIds.find((c) => file === getCoreAspectPackageName(c));
-
-    if (matchingCoreAspect) {
-      return (this.workspace || this.scope).resolveComponentId(matchingCoreAspect);
-    }
-
-    if (this.workspace) {
-      return this.workspace.getComponentIdByPath(file);
-    }
-    return null;
-  }
-
-  /**
-   * select the correct transformer for a node.
-   */
-  getTransformer(node: Node, context: SchemaExtractorContext) {
-    const transformers = flatten(this.schemaTransformerSlot.values());
-    const transformer = transformers.find((singleTransformer) => {
-      return singleTransformer.predicate(node);
-    });
-    if (!transformer) {
-      this.logger.debug(new TransformerNotFound(node, context.component, context.getLocation(node)).toString());
-      return undefined;
-    }
-
-    return transformer;
-  }
-
-  getAPITransformer(node: SchemaNode) {
-    const transformers = flatten(this.apiTransformerSlot.values());
-    const transformer = transformers.find((singleTransformer) => {
-      return singleTransformer.predicate(node);
-    });
-    if (!transformer) {
-      return undefined;
-    }
-
-    return transformer;
-  }
-
-  static from(options: ExtractorOptions) {
-    return (context: EnvContext) => {
-      const tsconfig = getTsconfig(options.tsconfig)?.config || { compilerOptions: options.compilerOptions };
-      const tsMain = context.getAspect<TypescriptMain>(TypescriptAspect.id);
-      const aspectLoaderMain = context.getAspect<AspectLoaderMain>(AspectLoaderAspect.id);
-
-      // When loading the env from a scope you don't have a workspace
-      const rootPath = tsMain.workspace?.path || tsMain.scope.path || '';
-
-      return new TypeScriptExtractor(
-        tsconfig,
-        tsMain.schemaTransformerSlot,
-        tsMain.apiTransformerSlot,
-        tsMain,
-        rootPath,
-        rootPath,
-        tsMain.depResolver,
-        tsMain.workspace,
-        tsMain.scope,
-        aspectLoaderMain,
-        context.createLogger(options.name)
-      );
-    };
-  }
-}