package.esm2022.src.linker.compiler.mjs Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of core Show documentation
Angular - the core framework
There is a newer version: 18.2.12
/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.dev/license
 */
import { Injectable } from '../di/injectable';
import { InjectionToken } from '../di/injection_token';
import { ComponentFactory as ComponentFactoryR3 } from '../render3/component_ref';
import { getComponentDef, getNgModuleDef } from '../render3/definition';
import { NgModuleFactory as NgModuleFactoryR3 } from '../render3/ng_module_ref';
import { maybeUnwrapFn } from '../render3/util/misc_utils';
import * as i0 from "../r3_symbols";
/**
 * Combination of NgModuleFactory and ComponentFactories.
 *
 * @publicApi
 *
 * @deprecated
 * Ivy JIT mode doesn't require accessing this symbol.
 */
export class ModuleWithComponentFactories {
    constructor(ngModuleFactory, componentFactories) {
        this.ngModuleFactory = ngModuleFactory;
        this.componentFactories = componentFactories;
    }
}
/**
 * Low-level service for running the angular compiler during runtime
 * to create {@link ComponentFactory}s, which
 * can later be used to create and render a Component instance.
 *
 * Each `@NgModule` provides an own `Compiler` to its injector,
 * that will use the directives/pipes of the ng module for compilation
 * of components.
 *
 * @publicApi
 *
 * @deprecated
 * Ivy JIT mode doesn't require accessing this symbol.
 */
export class Compiler {
    /**
     * Compiles the given NgModule and all of its components. All templates of the components
     * have to be inlined.
     */
    compileModuleSync(moduleType) {
        return new NgModuleFactoryR3(moduleType);
    }
    /**
     * Compiles the given NgModule and all of its components
     */
    compileModuleAsync(moduleType) {
        return Promise.resolve(this.compileModuleSync(moduleType));
    }
    /**
     * Same as {@link Compiler#compileModuleSync compileModuleSync} but also creates ComponentFactories for all components.
     */
    compileModuleAndAllComponentsSync(moduleType) {
        const ngModuleFactory = this.compileModuleSync(moduleType);
        const moduleDef = getNgModuleDef(moduleType);
        const componentFactories = maybeUnwrapFn(moduleDef.declarations).reduce((factories, declaration) => {
            const componentDef = getComponentDef(declaration);
            componentDef && factories.push(new ComponentFactoryR3(componentDef));
            return factories;
        }, []);
        return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);
    }
    /**
     * Same as {@link Compiler#compileModuleAsync compileModuleAsync} but also creates ComponentFactories for all components.
     */
    compileModuleAndAllComponentsAsync(moduleType) {
        return Promise.resolve(this.compileModuleAndAllComponentsSync(moduleType));
    }
    /**
     * Clears all caches.
     */
    clearCache() { }
    /**
     * Clears the cache for the given component/ngModule.
     */
    clearCacheFor(type) { }
    /**
     * Returns the id for a given NgModule, if one is defined and known to the compiler.
     */
    getModuleId(moduleType) {
        return undefined;
    }
    static { this.ɵfac = function Compiler_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || Compiler)(); }; }
    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: Compiler, factory: Compiler.ɵfac, providedIn: 'root' }); }
}
(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(Compiler, [{
        type: Injectable,
        args: [{ providedIn: 'root' }]
    }], null, null); })();
/**
 * Token to provide CompilerOptions in the platform injector.
 *
 * @publicApi
 */
export const COMPILER_OPTIONS = new InjectionToken(ngDevMode ? 'compilerOptions' : '');
/**
 * A factory for creating a Compiler
 *
 * @publicApi
 *
 * @deprecated
 * Ivy JIT mode doesn't require accessing this symbol.
 */
export class CompilerFactory {
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/compiler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAKrD,OAAO,EAAC,gBAAgB,IAAI,kBAAkB,EAAC,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAC,eAAe,IAAI,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;;AAKzD;;;;;;;GAOG;AACH,MAAM,OAAO,4BAA4B;IACvC,YACS,eAAmC,EACnC,kBAA2C;QAD3C,oBAAe,GAAf,eAAe,CAAoB;QACnC,uBAAkB,GAAlB,kBAAkB,CAAyB;IACjD,CAAC;CACL;AAED;;;;;;;;;;;;;GAaG;AAEH,MAAM,OAAO,QAAQ;IACnB;;;OAGG;IACH,iBAAiB,CAAI,UAAmB;QACtC,OAAO,IAAI,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAI,UAAmB;QACvC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACH,iCAAiC,CAAI,UAAmB;QACtD,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,cAAc,CAAC,UAAU,CAAE,CAAC;QAC9C,MAAM,kBAAkB,GAAG,aAAa,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,MAAM,CACrE,CAAC,SAAkC,EAAE,WAAsB,EAAE,EAAE;YAC7D,MAAM,YAAY,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;YAClD,YAAY,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC;YACrE,OAAO,SAAS,CAAC;QACnB,CAAC,EACD,EAA6B,CAC9B,CAAC;QACF,OAAO,IAAI,4BAA4B,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC;IAC/E,CAAC;IAED;;OAEG;IACH,kCAAkC,CAChC,UAAmB;QAEnB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iCAAiC,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7E,CAAC;IAED;;OAEG;IACH,UAAU,KAAU,CAAC;IAErB;;OAEG;IACH,aAAa,CAAC,IAAe,IAAG,CAAC;IAEjC;;OAEG;IACH,WAAW,CAAC,UAAqB;QAC/B,OAAO,SAAS,CAAC;IACnB,CAAC;yGAzDU,QAAQ;uEAAR,QAAQ,WAAR,QAAQ,mBADI,MAAM;;gFAClB,QAAQ;cADpB,UAAU;eAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;AAwEhC;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,cAAc,CAChD,SAAS,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,CACnC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,OAAgB,eAAe;CAEpC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {Injectable} from '../di/injectable';\nimport {InjectionToken} from '../di/injection_token';\nimport {StaticProvider} from '../di/interface/provider';\nimport {MissingTranslationStrategy} from '../i18n/tokens';\nimport {Type} from '../interface/type';\nimport {ViewEncapsulation} from '../metadata/view';\nimport {ComponentFactory as ComponentFactoryR3} from '../render3/component_ref';\nimport {getComponentDef, getNgModuleDef} from '../render3/definition';\nimport {NgModuleFactory as NgModuleFactoryR3} from '../render3/ng_module_ref';\nimport {maybeUnwrapFn} from '../render3/util/misc_utils';\n\nimport {ComponentFactory} from './component_factory';\nimport {NgModuleFactory} from './ng_module_factory';\n\n/**\n * Combination of NgModuleFactory and ComponentFactories.\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n */\nexport class ModuleWithComponentFactories<T> {\n  constructor(\n    public ngModuleFactory: NgModuleFactory<T>,\n    public componentFactories: ComponentFactory<any>[],\n  ) {}\n}\n\n/**\n * Low-level service for running the angular compiler during runtime\n * to create {@link ComponentFactory}s, which\n * can later be used to create and render a Component instance.\n *\n * Each `@NgModule` provides an own `Compiler` to its injector,\n * that will use the directives/pipes of the ng module for compilation\n * of components.\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n */\n@Injectable({providedIn: 'root'})\nexport class Compiler {\n  /**\n   * Compiles the given NgModule and all of its components. All templates of the components\n   * have to be inlined.\n   */\n  compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> {\n    return new NgModuleFactoryR3(moduleType);\n  }\n\n  /**\n   * Compiles the given NgModule and all of its components\n   */\n  compileModuleAsync<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> {\n    return Promise.resolve(this.compileModuleSync(moduleType));\n  }\n\n  /**\n   * Same as {@link Compiler#compileModuleSync compileModuleSync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsSync<T>(moduleType: Type<T>): ModuleWithComponentFactories<T> {\n    const ngModuleFactory = this.compileModuleSync(moduleType);\n    const moduleDef = getNgModuleDef(moduleType)!;\n    const componentFactories = maybeUnwrapFn(moduleDef.declarations).reduce(\n      (factories: ComponentFactory<any>[], declaration: Type<any>) => {\n        const componentDef = getComponentDef(declaration);\n        componentDef && factories.push(new ComponentFactoryR3(componentDef));\n        return factories;\n      },\n      [] as ComponentFactory<any>[],\n    );\n    return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n  }\n\n  /**\n   * Same as {@link Compiler#compileModuleAsync compileModuleAsync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsAsync<T>(\n    moduleType: Type<T>,\n  ): Promise<ModuleWithComponentFactories<T>> {\n    return Promise.resolve(this.compileModuleAndAllComponentsSync(moduleType));\n  }\n\n  /**\n   * Clears all caches.\n   */\n  clearCache(): void {}\n\n  /**\n   * Clears the cache for the given component/ngModule.\n   */\n  clearCacheFor(type: Type<any>) {}\n\n  /**\n   * Returns the id for a given NgModule, if one is defined and known to the compiler.\n   */\n  getModuleId(moduleType: Type<any>): string | undefined {\n    return undefined;\n  }\n}\n\n/**\n * Options for creating a compiler.\n *\n * @publicApi\n */\nexport type CompilerOptions = {\n  defaultEncapsulation?: ViewEncapsulation;\n  providers?: StaticProvider[];\n  preserveWhitespaces?: boolean;\n};\n\n/**\n * Token to provide CompilerOptions in the platform injector.\n *\n * @publicApi\n */\nexport const COMPILER_OPTIONS = new InjectionToken<CompilerOptions[]>(\n  ngDevMode ? 'compilerOptions' : '',\n);\n\n/**\n * A factory for creating a Compiler\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n */\nexport abstract class CompilerFactory {\n  abstract createCompiler(options?: CompilerOptions[]): Compiler;\n}\n"]}