TypeScript compiler-cli.createCompilerHost函数代码示例

 function createProgram(rootNames: string[], overrideOptions: ng.CompilerOptions = {}) {
   const options = testSupport.createCompilerOptions(overrideOptions);
   const host = ng.createCompilerHost({options});
   const program = ng.createProgram(
       {rootNames: rootNames.map(p => path.resolve(testSupport.basePath, p)), options, host});
   return {program, options};
 }

  it('should not emit generated files whose sources are outside of the rootDir', () => {
    testSupport.writeFiles({
      'src/main.ts': createModuleAndCompSource('main'),
      'src/index.ts': `
          export * from './main';
        `
    });
    const options =
        testSupport.createCompilerOptions({rootDir: path.resolve(testSupport.basePath, 'src')});
    const host = ng.createCompilerHost({options});
    const writtenFileNames: string[] = [];
    const oldWriteFile = host.writeFile;
    host.writeFile = (fileName, data, writeByteOrderMark) => {
      writtenFileNames.push(fileName);
      oldWriteFile(fileName, data, writeByteOrderMark);
    };

    compile(/*oldProgram*/ undefined, options, /*rootNames*/ undefined, host);

    // no emit for files from node_modules as they are outside of rootDir
    expect(writtenFileNames.some(f => /node_modules/.test(f))).toBe(false);

    // emit all gen files for files under src/
    testSupport.shouldExist('built/main.js');
    testSupport.shouldExist('built/main.d.ts');
    testSupport.shouldExist('built/main.ngfactory.js');
    testSupport.shouldExist('built/main.ngfactory.d.ts');
    testSupport.shouldExist('built/main.ngsummary.json');
  });

    it('should include non-formatted errors (e.g. invalid templateUrl)', () => {
      testSupport.write('src/index.ts', `
        import {Component, NgModule} from '@angular/core';

        @Component({
          selector: 'my-component',
          templateUrl: 'template.html',   // invalid template url
        })
        export class MyComponent {}

        @NgModule({
          declarations: [MyComponent]
        })
        export class MyModule {}
      `);

      const options = testSupport.createCompilerOptions();
      const host = ng.createCompilerHost({options});
      const program = ng.createProgram({
        rootNames: [path.resolve(testSupport.basePath, 'src/index.ts')],
        options,
        host,
      });

      const structuralErrors = program.getNgStructuralDiagnostics();
      expect(structuralErrors.length).toBe(1);
      expect(structuralErrors[0].messageText).toContain('Couldn\'t resolve resource template.html');
    });

       () => {
         testSupport.write('src/index.ts', fileWithGoodContent);

         // compile angular and produce .ngsummary.json / ngfactory.d.ts files
         compile();

         testSupport.write('src/ok.ts', fileWithGoodContent);
         testSupport.write('src/error.ts', fileWithStructuralError);

         // Make sure the ok.ts file is before the error.ts file,
         // so we added a .ngfactory.ts file for it.
         const allRootNames = resolveFiles(
             ['src/ok.ts', 'src/error.ts'].map(fn => path.resolve(testSupport.basePath, fn)));

         const options = testSupport.createCompilerOptions({
           noResolve: true,
           generateCodeForLibraries: false,
         });
         const host = ng.createCompilerHost({options});
         const originalGetSourceFile = host.getSourceFile;
         host.getSourceFile =
             (fileName: string, languageVersion: ts.ScriptTarget,
              onError?: ((message: string) => void) | undefined): ts.SourceFile => {
               // We should never try to load .ngfactory.ts files
               if (fileName.match(/\.ngfactory\.ts$/)) {
                 throw new Error(`Non existent ngfactory file: ` + fileName);
               }
               return originalGetSourceFile.call(host, fileName, languageVersion, onError);
             };
         const program = ng.createProgram({rootNames: allRootNames, options, host});
         const structuralErrors = program.getNgStructuralDiagnostics();
         expect(structuralErrors.length).toBe(1);
         expect(structuralErrors[0].messageText).toContain('Function calls are not supported.');
       });

 it('should typecheck templates even if skipTemplateCodegen is set', () => {
   testSupport.writeFiles({
     'src/main.ts': createModuleAndCompSource('main', `{{nonExistent}}`),
   });
   const options = testSupport.createCompilerOptions({skipTemplateCodegen: true});
   const host = ng.createCompilerHost({options});
   const program = ng.createProgram(
       {rootNames: [path.resolve(testSupport.basePath, 'src/main.ts')], options, host});
   const diags = program.getNgSemanticDiagnostics();
   expect(diags.length).toBe(1);
   expect(diags[0].messageText).toBe(`Property 'nonExistent' does not exist on type 'mainComp'.`);
 });

    function compile(oldProgram?: ng.Program): ng.Program {
      const options = testSupport.createCompilerOptions();
      const rootNames = [path.resolve(testSupport.basePath, 'src/index.ts')];

      const program = ng.createProgram({
        rootNames: rootNames,
        options: testSupport.createCompilerOptions(),
        host: ng.createCompilerHost({options}), oldProgram,
      });
      expectNoDiagnosticsInProgram(options, program);
      program.emit();
      return program;
    }