@teambit/typescript 0.0.553 → 0.0.557

package/dist/compiler-options.d.ts

@@ -1,8 +1,22 @@
 import type { CompilerOptions } from '@teambit/compiler';
 export declare type TypeScriptCompilerOptions = {
+    /**
+     * tsconfig to use during compilation.
+     */
     tsconfig: Record<string, any>;
+    /**
+     * path for .d.ts files to include during build.
+     */
     types: string[];
+    /**
+     * Run the compiler for .js files. this will only affect whether to run the compiler on the files
+     * or not. It won't change the tsconfig to support or not support js files.
+     */
     compileJs?: boolean;
+    /**
+     * Run the compiler for .js files. this will only affect whether to run the compiler on the files
+     * or not. It won't change the tsconfig to support or not support jsx files.
+     */
     compileJsx?: boolean;
 } & Partial<CompilerOptions>;
 export declare type TsCompilerOptionsWithoutTsConfig = Omit<TypeScriptCompilerOptions, 'tsconfig'>;

package/dist/typescript.compiler.d.ts

@@ -15,8 +15,14 @@ export declare class TypescriptCompiler implements Compiler {
     constructor(id: string, logger: Logger, options: TypeScriptCompilerOptions, tsModule: typeof ts);
     displayName: string;
     displayConfig(): string;
+    /**
+     * compile one file on the workspace
+     */
     transpileFile(fileContent: string, options: TranspileFileParams): TranspileFileOutput;
     preBuild(context: BuildContext): Promise<void>;
+    /**
+     * compile multiple components on the capsules
+     */
     build(context: BuildContext): Promise<BuiltTaskResult>;
     postBuild(context: BuildContext): Promise<void>;
     getArtifactDefinition(): {
@@ -24,11 +30,29 @@ export declare class TypescriptCompiler implements Compiler {
         name: string;
         globPatterns: string[];
     }[];
+    /**
+     * given a source file, return its parallel in the dists. e.g. index.ts => dist/index.js
+     */
     getDistPathBySrcPath(srcPath: string): string;
+    /**
+     * whether typescript is able to compile the given path
+     */
     isFileSupported(filePath: string): boolean;
+    /**
+     * 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 runTscBuild;
     private getFormatDiagnosticsHost;
     private writeTypes;
+    /**
+     * when using project-references, typescript adds a file "tsconfig.tsbuildinfo" which is not
+     * needed for the package.
+     */
     private writeNpmIgnore;
     private writeProjectReferencesTsConfig;
     private writeTsConfig;

package/dist/typescript.main.runtime.d.ts

@@ -15,11 +15,37 @@ export declare class TypescriptMain {
     private workspace?;
     private tsServer;
     constructor(logger: Logger, workspace?: Workspace | undefined);
+    /**
+     * create a new compiler.
+     */
     createCompiler(options: TypeScriptCompilerOptions, transformers?: TsConfigTransformer[], tsModule?: typeof ts): Compiler;
+    /**
+     * get TsserverClient instance if initiated already, otherwise, return undefined.
+     */
     getTsserverClient(): TsserverClient | undefined;
+    /**
+     * starts a tsserver process to communicate with its API.
+     * @param projectPath absolute path of the project root directory
+     * @param options TsserverClientOpts
+     * @param files optionally, if check-types is enabled, provide files to open and type check.
+     * @returns TsserverClient
+     */
     initTsserverClient(projectPath: string, options?: TsserverClientOpts, files?: string[]): Promise<TsserverClient>;
+    /**
+     * starts a tsserver process to communicate with its API. use only when running on the workspace.
+     * @param options TsserverClientOpts
+     * @param files optionally, if check-types is enabled, provide files to open and type check.
+     * @returns TsserverClient
+     */
     initTsserverClientFromWorkspace(options?: TsserverClientOpts, files?: string[]): Promise<TsserverClient>;
+    /**
+     * create an instance of a typescript semantic schema extractor.
+     */
     createSchemaExtractor(tsconfig: TsConfigSourceFile): SchemaExtractor;
+    /**
+     * add the default package json properties to the component
+     * :TODO @gilad why do we need this DSL? can't I just get the args here.
+     */
     getPackageJsonProps(): PackageJsonProps;
     private getAllFilesForTsserver;
     private onPreWatch;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/typescript",
-  "version": "0.0.553",
+  "version": "0.0.557",
   "homepage": "https://bit.dev/teambit/typescript/typescript",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.typescript",
     "name": "typescript",
-    "version": "0.0.553"
+    "version": "0.0.557"
   },
   "dependencies": {
     "@teambit/harmony": "0.2.11",
@@ -16,18 +16,18 @@
     "p-map-series": "2.1.0",
     "@babel/runtime": "7.12.18",
     "core-js": "^3.0.0",
-    "@teambit/compiler": "0.0.553",
-    "@teambit/typescript.modules.ts-config-mutator": "0.0.41",
-    "@teambit/bit-error": "0.0.370",
-    "@teambit/builder": "0.0.553",
-    "@teambit/isolator": "0.0.553",
-    "@teambit/logger": "0.0.469",
-    "@teambit/component": "0.0.553",
-    "@teambit/schema": "0.0.553",
-    "@teambit/cli": "0.0.384",
-    "@teambit/pkg": "0.0.553",
-    "@teambit/ts-server": "0.0.7",
-    "@teambit/workspace": "0.0.553"
+    "@teambit/compiler": "0.0.557",
+    "@teambit/typescript.modules.ts-config-mutator": "0.0.45",
+    "@teambit/bit-error": "0.0.374",
+    "@teambit/builder": "0.0.557",
+    "@teambit/isolator": "0.0.557",
+    "@teambit/logger": "0.0.473",
+    "@teambit/component": "0.0.557",
+    "@teambit/schema": "0.0.557",
+    "@teambit/cli": "0.0.388",
+    "@teambit/pkg": "0.0.557",
+    "@teambit/ts-server": "0.0.11",
+    "@teambit/workspace": "0.0.557"
   },
   "devDependencies": {
     "chai": "4.3.0",
@@ -39,10 +39,10 @@
     "@types/jest": "^26.0.0",
     "@types/react-dom": "^17.0.5",
     "@types/node": "12.20.4",
-    "@teambit/typescript.aspect-docs.typescript": "0.0.103"
+    "@teambit/typescript.aspect-docs.typescript": "0.0.107"
   },
   "peerDependencies": {
-    "@teambit/legacy": "1.0.170",
+    "@teambit/legacy": "1.0.174",
     "react-dom": "^16.8.0 || ^17.0.0",
     "react": "^16.8.0 || ^17.0.0"
   },
@@ -70,12 +70,20 @@
         "react": "-"
       },
       "peerDependencies": {
-        "@teambit/legacy": "1.0.170",
+        "@teambit/legacy": "1.0.174",
         "react-dom": "^16.8.0 || ^17.0.0",
         "react": "^16.8.0 || ^17.0.0"
       }
     }
   },
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "README.md",
+    "README.mdx",
+    "*.js",
+    "*.json"
+  ],
   "private": false,
   "engines": {
     "node": ">=12.22.0"

package/tsconfig.json

@@ -15,9 +15,9 @@
     "skipLibCheck": true,
     "moduleResolution": "node",
     "esModuleInterop": true,
-    "outDir": "dist",
     "composite": true,
     "emitDeclarationOnly": true,
+    "outDir": "dist",
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "allowSyntheticDefaultImports": true,
@@ -25,7 +25,6 @@
     "strict": true,
     "noImplicitAny": false,
     "rootDir": ".",
-    "removeComments": true,
     "preserveConstEnums": true,
     "resolveJsonModule": true
   },

package/compiler-options.ts

@@ -1,27 +0,0 @@
-import type { CompilerOptions } from '@teambit/compiler';
-
-export type TypeScriptCompilerOptions = {
-  /**
-   * tsconfig to use during compilation.
-   */
-  tsconfig: Record<string, any>;
-
-  /**
-   * path for .d.ts files to include during build.
-   */
-  types: string[];
-
-  /**
-   * Run the compiler for .js files. this will only affect whether to run the compiler on the files
-   * or not. It won't change the tsconfig to support or not support js files.
-   */
-  compileJs?: boolean;
-
-  /**
-   * Run the compiler for .js files. this will only affect whether to run the compiler on the files
-   * or not. It won't change the tsconfig to support or not support jsx files.
-   */
-  compileJsx?: boolean;
-} & Partial<CompilerOptions>;
-
-export type TsCompilerOptionsWithoutTsConfig = Omit<TypeScriptCompilerOptions, 'tsconfig'>;

package/index.ts

@@ -1,5 +0,0 @@
-export { TypescriptConfigMutator } from '@teambit/typescript.modules.ts-config-mutator';
-export { TypescriptCompiler } from './typescript.compiler';
-export type { TypescriptMain, TsConfigTransformer } from './typescript.main.runtime';
-export type { TypeScriptCompilerOptions, TsCompilerOptionsWithoutTsConfig } from './compiler-options';
-export { TypescriptAspect } from './typescript.aspect';

package/types/asset.d.ts

@@ -1,29 +0,0 @@
-declare module '*.png' {
-  const value: any;
-  export = value;
-}
-declare module '*.svg' {
-  import type { FunctionComponent, SVGProps } from 'react';
-
-  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
-  const src: string;
-  export default src;
-}
-
-// @TODO Gilad
-declare module '*.jpg' {
-  const value: any;
-  export = value;
-}
-declare module '*.jpeg' {
-  const value: any;
-  export = value;
-}
-declare module '*.gif' {
-  const value: any;
-  export = value;
-}
-declare module '*.bmp' {
-  const value: any;
-  export = value;
-}

package/types/style.d.ts

@@ -1,42 +0,0 @@
-declare module '*.module.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-declare module '*.module.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.module.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.less' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.css' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.sass' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.scss' {
-  const classes: { readonly [key: string]: string };
-  export default classes;
-}
-
-declare module '*.mdx' {
-  const component: any;
-  export default component;
-}

package/typescript.aspect.ts

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

package/typescript.compiler.spec.ts

@@ -1,63 +0,0 @@
-import { Logger } from '@teambit/logger';
-import ts from 'typescript';
-import { expect } from 'chai';
-import path from 'path';
-import { TypescriptAspect } from './typescript.aspect';
-
-import { TypescriptCompiler } from './typescript.compiler';
-import type { TsCompilerOptionsWithoutTsConfig } from './compiler-options';
-
-const defaultOpts = {
-  tsconfig: {},
-  types: [],
-};
-
-describe('TypescriptCompiler', () => {
-  describe('getDistPathBySrcPath', () => {
-    it('should replace the extension with .js and prepend the dist dir', () => {
-      const tsCompiler = getTsCompiler();
-      expect(tsCompiler.getDistPathBySrcPath('index.ts')).to.equal(path.join('dist', 'index.js'));
-      expect(tsCompiler.getDistPathBySrcPath('index.tsx')).to.equal(path.join('dist', 'index.js'));
-    });
-    it('should not replace the extension if the file is not supported', () => {
-      const tsCompiler = getTsCompiler();
-      expect(tsCompiler.getDistPathBySrcPath('style.css')).to.equal(path.join('dist', 'style.css'));
-      expect(tsCompiler.getDistPathBySrcPath('index.d.ts')).to.equal(path.join('dist', 'index.d.ts'));
-    });
-  });
-  describe('isFileSupported', () => {
-    it('should support .ts files', () => {
-      const tsCompiler = getTsCompiler();
-      expect(tsCompiler.isFileSupported('index.ts')).to.be.true;
-    });
-    it('should support .tsx files', () => {
-      const tsCompiler = getTsCompiler();
-      expect(tsCompiler.isFileSupported('index.tsx')).to.be.true;
-    });
-    it('should not support .jsx files by default', () => {
-      const tsCompiler = getTsCompiler();
-      expect(tsCompiler.isFileSupported('index.jsx')).to.be.false;
-    });
-    it('should not support .js files by default', () => {
-      const tsCompiler = getTsCompiler();
-      expect(tsCompiler.isFileSupported('index.js')).to.be.false;
-    });
-    it('should support .jsx files when passing compileJsx', () => {
-      const tsCompiler = getTsCompiler({ compileJsx: true, ...defaultOpts });
-      expect(tsCompiler.isFileSupported('index.jsx')).to.be.true;
-    });
-    it('should support .js files when passing compileJs', () => {
-      const tsCompiler = getTsCompiler({ compileJs: true, ...defaultOpts });
-      expect(tsCompiler.isFileSupported('index.js')).to.be.true;
-    });
-    it('should not support .d.ts files', () => {
-      const tsCompiler = getTsCompiler();
-      expect(tsCompiler.isFileSupported('index.d.ts')).to.be.false;
-    });
-  });
-});
-
-function getTsCompiler(opts: TsCompilerOptionsWithoutTsConfig = defaultOpts) {
-  const finalOpts = Object.assign({}, defaultOpts, opts);
-  return new TypescriptCompiler(TypescriptAspect.id, new Logger('test'), finalOpts, ts);
-}

package/typescript.compiler.ts

@@ -1,293 +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 PackageJsonFile from '@teambit/legacy/dist/consumer/component/package-json-file';
-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';
-
-  displayConfig() {
-    return this.stringifyTsconfig(this.options.tsconfig);
-  }
-
-  /**
-   * 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,
-    };
-  }
-
-  async postBuild(context: BuildContext) {
-    await Promise.all(
-      context.capsuleNetwork.seedersCapsules.map(async (capsule) => {
-        const packageJson = PackageJsonFile.loadFromCapsuleSync(capsule.path);
-        // the types['index.ts'] is needed only during the build to avoid errors when tsc finds the
-        // same type once in the d.ts and once in the ts file.
-        if (packageJson.packageJsonObject.types) {
-          delete packageJson.packageJsonObject.types;
-          await packageJson.write();
-        }
-      })
-    );
-  }
-
-  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 = network.graphCapsules;
-    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.composition.tsx

@@ -1,7 +0,0 @@
-import React from 'react';
-
-export const Logo = () => (
-  <div style={{ height: '100%', display: 'flex', justifyContent: 'center' }}>
-    <img style={{ width: 70 }} src="https://static.bit.dev/brands/logo-typescript.svg" />
-  </div>
-);

package/typescript.docs.mdx

@@ -1,8 +0,0 @@
----
-description: Typescript compilation for Bit components.
-labels: ['typescript', 'compiler', 'bit', 'extension', 'aspect']
----
-
-import { Typescript } from '@teambit/typescript.aspect-docs.typescript';
-
-<Typescript />

package/typescript.extractor.ts

@@ -1,33 +0,0 @@
-// import { tmpdir } from 'os';
-import { TsConfigSourceFile } from 'typescript';
-// import { resolve, join } from 'path';
-import { Module, SchemaExtractor } from '@teambit/schema';
-import { Component } from '@teambit/component';
-import { Application } from 'typedoc';
-
-export class TypeScriptExtractor implements SchemaExtractor {
-  constructor(private tsconfig: TsConfigSourceFile) {}
-
-  async extract(component: Component) {
-    // const tsconfig = this.tsconfig;
-    const paths = component.state.filesystem.files.map((file) => file.path).filter((path) => path.endsWith('index.ts'));
-    // const paths = ['/Users/ranmizrahi/Bit/bit/scopes/workspace/workspace/index.ts'];
-    const app = new Application();
-    app.bootstrap({
-      // typedoc options here
-      entryPoints: paths,
-    });
-    const project = app.convert();
-    // typedocApp.options.setValues({
-    //   inputFiles: paths,
-    //   allowJs: true,
-    //   lib: ['lib.es2015.d.ts', 'lib.es2019.d.ts', 'lib.es6.d.ts', 'lib.dom.d.ts', 'lib.dom.iterable.d.ts'],
-    //   jsx: 2,
-    //   noEmit: true,
-    //   exclude: ['node_modules', '*.scss'],
-    //   esModuleInterop: true,
-    // });
-    if (!project) throw new Error('typedoc failed generating docs');
-    return app.serializer.projectToObject(project) as any as Module;
-  }
-}

package/typescript.main.runtime.ts

@@ -1,165 +0,0 @@
-import ts, { TsConfigSourceFile } from 'typescript';
-import { MainRuntime } from '@teambit/cli';
-import { Compiler } from '@teambit/compiler';
-import { Logger, LoggerAspect, LoggerMain } from '@teambit/logger';
-import { SchemaAspect, SchemaExtractor, SchemaMain } from '@teambit/schema';
-import { PackageJsonProps } from '@teambit/pkg';
-import { TypescriptConfigMutator } from '@teambit/typescript.modules.ts-config-mutator';
-import WorkspaceAspect from '@teambit/workspace';
-import type { WatchOptions, Workspace } from '@teambit/workspace';
-import pMapSeries from 'p-map-series';
-import { TsserverClient, TsserverClientOpts } from '@teambit/ts-server';
-import type { Component } from '@teambit/component';
-import { TypeScriptExtractor } from './typescript.extractor';
-import { TypeScriptCompilerOptions } from './compiler-options';
-import { TypescriptAspect } from './typescript.aspect';
-import { TypescriptCompiler } from './typescript.compiler';
-import { TypeScriptParser } from './typescript.parser';
-
-export type TsMode = 'build' | 'dev';
-
-export type TsConfigTransformContext = {
-  // mode: TsMode;
-};
-
-export type TsConfigTransformer = (
-  config: TypescriptConfigMutator,
-  context: TsConfigTransformContext
-) => TypescriptConfigMutator;
-
-export class TypescriptMain {
-  private tsServer: TsserverClient;
-  constructor(private logger: Logger, private workspace?: Workspace) {
-    if (this.workspace) {
-      this.workspace.registerOnPreWatch(this.onPreWatch.bind(this));
-      this.workspace.registerOnComponentChange(this.onComponentChange.bind(this));
-      this.workspace.registerOnComponentAdd(this.onComponentChange.bind(this));
-    }
-  }
-  /**
-   * create a new compiler.
-   */
-  createCompiler(
-    options: TypeScriptCompilerOptions,
-    transformers: TsConfigTransformer[] = [],
-    tsModule = ts
-  ): Compiler {
-    const configMutator = new TypescriptConfigMutator(options);
-    const transformerContext: TsConfigTransformContext = {};
-    const afterMutation = runTransformersWithContext(configMutator.clone(), transformers, transformerContext);
-    return new TypescriptCompiler(TypescriptAspect.id, this.logger, afterMutation.raw, tsModule);
-  }
-
-  /**
-   * get TsserverClient instance if initiated already, otherwise, return undefined.
-   */
-  getTsserverClient(): TsserverClient | undefined {
-    return this.tsServer;
-  }
-
-  /**
-   * starts a tsserver process to communicate with its API.
-   * @param projectPath absolute path of the project root directory
-   * @param options TsserverClientOpts
-   * @param files optionally, if check-types is enabled, provide files to open and type check.
-   * @returns TsserverClient
-   */
-  async initTsserverClient(
-    projectPath: string,
-    options: TsserverClientOpts = {},
-    files: string[] = []
-  ): Promise<TsserverClient> {
-    this.tsServer = new TsserverClient(projectPath, this.logger, options, files);
-    this.tsServer.init();
-    return this.tsServer;
-  }
-
-  /**
-   * starts a tsserver process to communicate with its API. use only when running on the workspace.
-   * @param options TsserverClientOpts
-   * @param files optionally, if check-types is enabled, provide files to open and type check.
-   * @returns TsserverClient
-   */
-  async initTsserverClientFromWorkspace(
-    options: TsserverClientOpts = {},
-    files: string[] = []
-  ): Promise<TsserverClient> {
-    if (!this.workspace) {
-      throw new Error(`initTsserverClientFromWorkspace: workspace was not found`);
-    }
-    return this.initTsserverClient(this.workspace.path, options, files);
-  }
-
-  /**
-   * create an instance of a typescript semantic schema extractor.
-   */
-  createSchemaExtractor(tsconfig: TsConfigSourceFile): SchemaExtractor {
-    return new TypeScriptExtractor(tsconfig);
-  }
-
-  /**
-   * add the default package json properties to the component
-   * :TODO @gilad why do we need this DSL? can't I just get the args here.
-   */
-  getPackageJsonProps(): PackageJsonProps {
-    return {
-      main: 'dist/{main}.js',
-      types: '{main}.ts',
-    };
-  }
-
-  private getAllFilesForTsserver(components: Component[]): string[] {
-    const files = components
-      .map((c) => c.filesystem.files)
-      .flat()
-      .map((f) => f.path);
-    return files.filter((f) => f.endsWith('.ts') || f.endsWith('.tsx'));
-  }
-
-  private async onPreWatch(components: Component[], watchOpts: WatchOptions) {
-    const workspace = this.workspace;
-    if (!workspace || !watchOpts.spawnTSServer) {
-      return;
-    }
-    const { verbose, checkTypes } = watchOpts;
-    const files = checkTypes ? this.getAllFilesForTsserver(components) : [];
-    await this.initTsserverClientFromWorkspace({ verbose, checkTypes }, files);
-  }
-
-  private async onComponentChange(component: Component, files: string[]) {
-    if (!this.tsServer) {
-      return {
-        results: 'N/A',
-      };
-    }
-    await pMapSeries(files, (file) => this.tsServer.onFileChange(file));
-    return {
-      results: 'succeed',
-    };
-  }
-
-  static runtime = MainRuntime;
-  static dependencies = [SchemaAspect, LoggerAspect, WorkspaceAspect];
-
-  static async provider([schema, loggerExt, workspace]: [SchemaMain, LoggerMain, Workspace]) {
-    schema.registerParser(new TypeScriptParser());
-    const logger = loggerExt.createLogger(TypescriptAspect.id);
-    schema.registerParser(new TypeScriptParser(logger));
-
-    return new TypescriptMain(logger, workspace);
-  }
-}
-
-TypescriptAspect.addRuntime(TypescriptMain);
-
-export function runTransformersWithContext(
-  config: TypescriptConfigMutator,
-  transformers: TsConfigTransformer[] = [],
-  context: TsConfigTransformContext
-): TypescriptConfigMutator {
-  if (!Array.isArray(transformers)) return config;
-  const newConfig = transformers.reduce((acc, transformer) => {
-    return transformer(acc, context);
-  }, config);
-  return newConfig;
-}

package/typescript.parser.spec.ts

@@ -1,129 +0,0 @@
-import ts from 'typescript';
-import { expect } from 'chai';
-
-import { TypeScriptParser } from './typescript.parser';
-
-describe('TypescriptParser', () => {
-  describe('getExports', () => {
-    const exampleArrowFunction = `
-      export const arrow = () => { return 3; }
-      arrow.textProperty = "propertyValue";
-    `;
-
-    const exampleFunction = `
-      export function func() { return 3; }
-      func.textProperty = "propertyValue";
-    `;
-
-    const exampleClass = `
-      export class classy{ render() { return 3; } }
-      classy.textProperty = "propertyValue";
-    `;
-
-    it('should parse arrowFunctions', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleArrowFunction, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportArrow = exports.find((x) => x.identifier === 'arrow');
-
-      expect(exportArrow).to.exist;
-    });
-
-    it('should parse function exports', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFunction, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportFunction = exports.find((x) => x.identifier === 'func');
-
-      expect(exportFunction).to.exist;
-    });
-
-    it('should parse classes', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleClass, ts.ScriptTarget.Latest);
-      const exports = new TypeScriptParser().getExports(ast);
-
-      const exportClass = exports.find((x) => x.identifier === 'classy');
-
-      expect(exportClass).to.exist;
-    });
-
-    describe('staticProperties', () => {
-      it('should include staticProperties, when on arrowFunctions', () => {
-        const ast = ts.createSourceFile('example.tsx', exampleArrowFunction, ts.ScriptTarget.Latest);
-        const exports = new TypeScriptParser().getExports(ast);
-
-        const exportArrow = exports.find((x) => x.identifier === 'arrow');
-
-        expect(exportArrow?.staticProperties?.get('textProperty')).to.equal('propertyValue');
-      });
-
-      it('should include staticProperties, when on regular functions', () => {
-        const ast = ts.createSourceFile('example.tsx', exampleFunction, ts.ScriptTarget.Latest);
-        const exports = new TypeScriptParser().getExports(ast);
-
-        const exportClass = exports.find((x) => x.identifier === 'func');
-
-        expect(exportClass?.staticProperties?.get('textProperty')).to.equal('propertyValue');
-      });
-
-      it('should include staticProperties, when on classes', () => {
-        const ast = ts.createSourceFile('example.tsx', exampleClass, ts.ScriptTarget.Latest);
-        const exports = new TypeScriptParser().getExports(ast);
-
-        const exportClass = exports.find((x) => x.identifier === 'classy');
-
-        expect(exportClass?.staticProperties?.get('textProperty')).to.equal('propertyValue');
-      });
-    });
-  });
-
-  describe('collectStaticProperties', () => {
-    const exampleFile = `
-      export const hello = () => { return 3; }
-
-      hello.text = "is";
-      hello.count = 3;
-      hello.nullish = null;
-      hello.undef = undefined;
-      hello.disable = false;
-      hello.enable = true;
-      hello.complextLiteral = \`what \${hello.text} it?\`;
-      hello.nonAssignedProperty += 'value';
-    `;
-
-    it('should parse all primitive values', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFile, ts.ScriptTarget.Latest);
-      const staticProperties = new TypeScriptParser().parseStaticProperties(ast);
-
-      expect(staticProperties).to.exist;
-
-      const exportHello = staticProperties.get('hello');
-      expect(exportHello).to.exist;
-
-      expect(exportHello?.get('text')).to.equal('is');
-      expect(exportHello?.get('count')).to.equal(3);
-      expect(exportHello?.get('nullish')).to.equal(null);
-      expect(exportHello?.get('undef')).to.equal(undefined);
-      expect(exportHello?.get('disable')).to.equal(false);
-      expect(exportHello?.get('enable')).to.equal(true);
-
-      expect(exportHello?.has('complextLiteral')).to.be.false;
-    });
-
-    it('should skip non primitive values', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFile, ts.ScriptTarget.Latest);
-      const staticProperties = new TypeScriptParser().parseStaticProperties(ast);
-      const exportHello = staticProperties.get('hello');
-
-      expect(exportHello?.has('complextLiteral')).to.be.false;
-    });
-
-    it('should skip non assignment statements', () => {
-      const ast = ts.createSourceFile('example.tsx', exampleFile, ts.ScriptTarget.Latest);
-      const staticProperties = new TypeScriptParser().parseStaticProperties(ast);
-      const exportHello = staticProperties.get('hello');
-
-      expect(exportHello?.has('nonAssignedProperty')).to.be.false;
-    });
-  });
-});

package/typescript.parser.ts

@@ -1,102 +0,0 @@
-import { Export, Module, Parser, StaticProperties } from '@teambit/schema';
-import { Logger } from '@teambit/logger';
-import { readFileSync } from 'fs-extra';
-import ts, {
-  isClassDeclaration,
-  isFunctionDeclaration,
-  isVariableStatement,
-  SourceFile,
-  VariableStatement,
-} from 'typescript';
-
-export class TypeScriptParser implements Parser {
-  public extension = /^.*\.(js|jsx|ts|tsx)$/;
-
-  getExports(sourceFile: SourceFile): Export[] {
-    const staticProperties = this.parseStaticProperties(sourceFile);
-
-    const exports = sourceFile.statements.filter((statement) => {
-      if (!statement.modifiers) return false;
-      return statement.modifiers.find((modifier) => {
-        return modifier.kind === ts.SyntaxKind.ExportKeyword;
-      });
-    });
-
-    const exportModels = exports.map((statement) => {
-      // todo refactor to a registry of variable statements.
-      if (isVariableStatement(statement)) {
-        const child = (statement as VariableStatement).declarationList.declarations[0];
-        const name = (child as any).name.text;
-        return new Export(name, staticProperties.get(name));
-      }
-
-      if (isFunctionDeclaration(statement)) {
-        if (!statement.name) return undefined;
-        const name = statement.name.text;
-        return new Export(name, staticProperties.get(name));
-      }
-
-      if (isClassDeclaration(statement)) {
-        if (!statement.name) return undefined;
-        const name = statement.name.text;
-        return new Export(name, staticProperties.get(name));
-      }
-
-      return undefined;
-    });
-    const withoutEmpty = exportModels.filter((exportModel) => exportModel !== undefined);
-    // @ts-ignore
-    return withoutEmpty;
-  }
-
-  parseModule(modulePath: string) {
-    const ast = ts.createSourceFile(modulePath, readFileSync(modulePath, 'utf8'), ts.ScriptTarget.Latest);
-
-    const moduleExports = this.getExports(ast);
-
-    return new Module(moduleExports);
-  }
-
-  parseStaticProperties(sourceFile: SourceFile) {
-    // TODO - should we also parse staticProperties inside classes / objects?
-
-    const exportStaticProperties = new Map<string, StaticProperties>();
-
-    sourceFile.statements.forEach((statement) => {
-      try {
-        if (!ts.isExpressionStatement(statement)) return;
-        if (!ts.isBinaryExpression(statement.expression)) return;
-        if (statement.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
-        if (!ts.isPropertyAccessExpression(statement.expression.left)) return;
-        if (!ts.isIdentifier(statement.expression.left.expression)) return;
-
-        const targetName = statement.expression.left.expression.text;
-        const propertyName = statement.expression.left.name.text;
-
-        if (!exportStaticProperties.has(targetName)) exportStaticProperties.set(targetName, new Map());
-
-        const existingProperties = exportStaticProperties.get(targetName);
-
-        if (ts.isStringLiteral(statement.expression.right)) {
-          existingProperties?.set(propertyName, statement.expression.right.text);
-        } else if (ts.isNumericLiteral(statement.expression.right)) {
-          existingProperties?.set(propertyName, +statement.expression.right.text);
-        } else if (statement.expression.right.kind === ts.SyntaxKind.UndefinedKeyword) {
-          existingProperties?.set(propertyName, undefined);
-        } else if (statement.expression.right.kind === ts.SyntaxKind.NullKeyword) {
-          existingProperties?.set(propertyName, null);
-        } else if (statement.expression.right.kind === ts.SyntaxKind.TrueKeyword) {
-          existingProperties?.set(propertyName, true);
-        } else if (statement.expression.right.kind === ts.SyntaxKind.FalseKeyword) {
-          existingProperties?.set(propertyName, false);
-        }
-      } catch (err) {
-        this.logger?.error('failed parsing static properties', err);
-      }
-    });
-
-    return exportStaticProperties;
-  }
-
-  constructor(private logger?: Logger | undefined) {}
-}