TypeScript compiler.parseTemplate函数代码示例

    get: () => {
      if (ngComponentDef === null) {
        if (componentNeedsResolution(metadata)) {
          const error = [`Component '${stringify(type)}' is not resolved:`];
          if (metadata.templateUrl) {
            error.push(` - templateUrl: ${stringify(metadata.templateUrl)}`);
          }
          if (metadata.styleUrls && metadata.styleUrls.length) {
            error.push(` - styleUrls: ${JSON.stringify(metadata.styleUrls)}`);
          }
          error.push(`Did you run and wait for 'resolveComponentResources()'?`);
          throw new Error(error.join('\n'));
        }
        // The ConstantPool is a requirement of the JIT'er.
        const constantPool = new ConstantPool();

        // Parse the template and check for errors.
        const template = parseTemplate(
            metadata.template !, `ng://${stringify(type)}/template.html`, {
              preserveWhitespaces: metadata.preserveWhitespaces || false,
            },
            '');
        if (template.errors !== undefined) {
          const errors = template.errors.map(err => err.toString()).join(', ');
          throw new Error(
              `Errors during JIT compilation of template for ${stringify(type)}: ${errors}`);
        }

        // Compile the component metadata, including template, into an expression.
        // TODO(alxhub): implement inputs, outputs, queries, etc.
        const res = compileR3Component(
            {
              ...directiveMetadata(type, metadata),
              template,
              directives: new Map(),
              pipes: new Map(),
              viewQueries: [],
              wrapDirectivesInClosure: false,
              styles: metadata.styles || [],
              encapsulation: metadata.encapsulation || ViewEncapsulation.Emulated,
              animations: metadata.animations || null
            },
            constantPool, makeBindingParser());
        const preStatements = [...constantPool.statements, ...res.statements];

        ngComponentDef = jitExpression(
            res.expression, angularCoreEnv, `ng://${type.name}/ngComponentDef.js`, preStatements);

        // If component compilation is async, then the @NgModule annotation which declares the
        // component may execute and set an ngSelectorScope property on the component type. This
        // allows the component to patch itself with directiveDefs from the module after it
        // finishes compiling.
        if (hasSelectorScope(type)) {
          const scopes = transitiveScopesFor(type.ngSelectorScope);
          patchComponentDefWithScope(ngComponentDef, scopes);
        }
      }
      return ngComponentDef;
    },

export function parseHtmlGracefully(htmlContent: string, filePath: string): Node[]|null {
  try {
    return parseTemplate(htmlContent, filePath).nodes;
  } catch {
    // Do nothing if the template couldn't be parsed. We don't want to throw any
    // exception if a template is syntactically not valid. e.g. template could be
    // using preprocessor syntax.
    return null;
  }
}

    get: () => {
      if (def === null) {
        // The ConstantPool is a requirement of the JIT'er.
        const constantPool = new ConstantPool();

        // Parse the template and check for errors.
        const template = parseTemplate(templateStr, `ng://${type.name}/template.html`, {
          preserveWhitespaces: metadata.preserveWhitespaces || false,
        });
        if (template.errors !== undefined) {
          const errors = template.errors.map(err => err.toString()).join(', ');
          throw new Error(`Errors during JIT compilation of template for ${type.name}: ${errors}`);
        }

        // Compile the component metadata, including template, into an expression.
        // TODO(alxhub): implement inputs, outputs, queries, etc.
        const res = compileR3Component(
            {
              ...directiveMetadata(type, metadata),
              template,
              directives: new Map(),
              pipes: new Map(),
              viewQueries: [],
            },
            constantPool, makeBindingParser());

        def = jitExpression(
            res.expression, angularCoreEnv, `ng://${type.name}/ngComponentDef.js`, constantPool);

        // If component compilation is async, then the @NgModule annotation which declares the
        // component may execute and set an ngSelectorScope property on the component type. This
        // allows the component to patch itself with directiveDefs from the module after it finishes
        // compiling.
        if (hasSelectorScope(type)) {
          patchComponentDefWithScope(def, type.ngSelectorScope);
        }
      }
      return def;
    },

  analyze(node: ts.ClassDeclaration, decorator: Decorator): AnalysisOutput<R3ComponentMetadata> {
    if (decorator.args === null || decorator.args.length !== 1) {
      throw new Error(`Incorrect number of arguments to @Component decorator`);
    }
    const meta = decorator.args[0];
    if (!ts.isObjectLiteralExpression(meta)) {
      throw new Error(`Decorator argument must be literal.`);
    }

    // @Component inherits @Directive, so begin by extracting the @Directive metadata and building
    // on it.
    const directiveMetadata =
        extractDirectiveMetadata(node, decorator, this.checker, this.reflector);
    if (directiveMetadata === undefined) {
      // `extractDirectiveMetadata` returns undefined when the @Directive has `jit: true`. In this
      // case, compilation of the decorator is skipped. Returning an empty object signifies
      // that no analysis was produced.
      return {};
    }

    // Next, read the `@Component`-specific fields.
    const component = reflectObjectLiteral(meta);

    // Resolve and parse the template.
    if (!component.has('template')) {
      throw new Error(`For now, components must directly have a template.`);
    }
    const templateExpr = component.get('template') !;
    const templateStr = staticallyResolve(templateExpr, this.checker);
    if (typeof templateStr !== 'string') {
      throw new Error(`Template must statically resolve to a string: ${node.name!.text}`);
    }

    let preserveWhitespaces: boolean = false;
    if (component.has('preserveWhitespaces')) {
      const value = staticallyResolve(component.get('preserveWhitespaces') !, this.checker);
      if (typeof value !== 'boolean') {
        throw new Error(`preserveWhitespaces must resolve to a boolean if present`);
      }
      preserveWhitespaces = value;
    }

    const template = parseTemplate(
        templateStr, `${node.getSourceFile().fileName}#${node.name!.text}/template.html`,
        {preserveWhitespaces});
    if (template.errors !== undefined) {
      throw new Error(
          `Errors parsing template: ${template.errors.map(e => e.toString()).join(', ')}`);
    }

    // If the component has a selector, it should be registered with the `SelectorScopeRegistry` so
    // when this component appears in an `@NgModule` scope, its selector can be determined.
    if (directiveMetadata.selector !== null) {
      this.scopeRegistry.registerSelector(node, directiveMetadata.selector);
    }

    return {
      analysis: {
        ...directiveMetadata,
        template,
        viewQueries: [],

        // These will be replaced during the compilation step, after all `NgModule`s have been
        // analyzed and the full compilation scope for the component can be realized.
        pipes: EMPTY_MAP,
        directives: EMPTY_MAP,
      }
    };
  }