source: trip-planner-front/node_modules/@angular/compiler/esm2015/src/render3/partial/injectable.js@ e29cc2e

/**
 * @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.io/license
 */
import { createInjectableType } from '../../injectable_compiler_2';
import * as o from '../../output/output_ast';
import { Identifiers as R3 } from '../r3_identifiers';
import { DefinitionMap } from '../view/util';
import { compileDependency, generateForwardRef } from './util';
/**
 * Every time we make a breaking change to the declaration interface or partial-linker behavior, we
 * must update this constant to prevent old partial-linkers from incorrectly processing the
 * declaration.
 *
 * Do not include any prerelease in these versions as they are ignored.
 */
const MINIMUM_PARTIAL_LINKER_VERSION = '12.0.0';
/**
 * Compile a Injectable declaration defined by the `R3InjectableMetadata`.
 */
export function compileDeclareInjectableFromMetadata(meta) {
    const definitionMap = createInjectableDefinitionMap(meta);
    const expression = o.importExpr(R3.declareInjectable).callFn([definitionMap.toLiteralMap()]);
    const type = createInjectableType(meta);
    return { expression, type, statements: [] };
}
/**
 * Gathers the declaration fields for a Injectable into a `DefinitionMap`.
 */
export function createInjectableDefinitionMap(meta) {
    const definitionMap = new DefinitionMap();
    definitionMap.set('minVersion', o.literal(MINIMUM_PARTIAL_LINKER_VERSION));
    definitionMap.set('version', o.literal('12.2.13'));
    definitionMap.set('ngImport', o.importExpr(R3.core));
    definitionMap.set('type', meta.internalType);
    // Only generate providedIn property if it has a non-null value
    if (meta.providedIn !== undefined) {
        const providedIn = convertFromProviderExpression(meta.providedIn);
        if (providedIn.value !== null) {
            definitionMap.set('providedIn', providedIn);
        }
    }
    if (meta.useClass !== undefined) {
        definitionMap.set('useClass', convertFromProviderExpression(meta.useClass));
    }
    if (meta.useExisting !== undefined) {
        definitionMap.set('useExisting', convertFromProviderExpression(meta.useExisting));
    }
    if (meta.useValue !== undefined) {
        definitionMap.set('useValue', convertFromProviderExpression(meta.useValue));
    }
    // Factories do not contain `ForwardRef`s since any types are already wrapped in a function call
    // so the types will not be eagerly evaluated. Therefore we do not need to process this expression
    // with `convertFromProviderExpression()`.
    if (meta.useFactory !== undefined) {
        definitionMap.set('useFactory', meta.useFactory);
    }
    if (meta.deps !== undefined) {
        definitionMap.set('deps', o.literalArr(meta.deps.map(compileDependency)));
    }
    return definitionMap;
}
/**
 * Convert an `R3ProviderExpression` to an `Expression`, possibly wrapping its expression in a
 * `forwardRef()` call.
 *
 * If `R3ProviderExpression.isForwardRef` is true then the expression was originally wrapped in a
 * `forwardRef()` call to prevent the value from being eagerly evaluated in the code.
 *
 * Normally, the linker will statically process the code, putting the `expression` inside a factory
 * function so the `forwardRef()` wrapper is not evaluated before it has been defined. But if the
 * partial declaration is evaluated by the JIT compiler the `forwardRef()` call is still needed to
 * prevent eager evaluation of the `expression`.
 *
 * So in partial declarations, expressions that could be forward-refs are wrapped in `forwardRef()`
 * calls, and this is then unwrapped in the linker as necessary.
 *
 * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
 * `packages/compiler/src/jit_compiler_facade.ts` for more information.
 */
function convertFromProviderExpression({ expression, isForwardRef }) {
    return isForwardRef ? generateForwardRef(expression) : expression;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injectable.js","sourceRoot":"","sources":["../../../../../../../../packages/compiler/src/render3/partial/injectable.ts"],"names":[],"mappings":"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","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.io/license\n */\nimport {createInjectableType, R3InjectableMetadata, R3ProviderExpression} from '../../injectable_compiler_2';\nimport * as o from '../../output/output_ast';\nimport {Identifiers as R3} from '../r3_identifiers';\nimport {R3CompiledExpression} from '../util';\nimport {DefinitionMap} from '../view/util';\n\nimport {R3DeclareInjectableMetadata} from './api';\nimport {compileDependency, generateForwardRef} from './util';\n\n/**\n * Every time we make a breaking change to the declaration interface or partial-linker behavior, we\n * must update this constant to prevent old partial-linkers from incorrectly processing the\n * declaration.\n *\n * Do not include any prerelease in these versions as they are ignored.\n */\nconst MINIMUM_PARTIAL_LINKER_VERSION = '12.0.0';\n\n/**\n * Compile a Injectable declaration defined by the `R3InjectableMetadata`.\n */\nexport function compileDeclareInjectableFromMetadata(meta: R3InjectableMetadata):\n    R3CompiledExpression {\n  const definitionMap = createInjectableDefinitionMap(meta);\n\n  const expression = o.importExpr(R3.declareInjectable).callFn([definitionMap.toLiteralMap()]);\n  const type = createInjectableType(meta);\n\n  return {expression, type, statements: []};\n}\n\n/**\n * Gathers the declaration fields for a Injectable into a `DefinitionMap`.\n */\nexport function createInjectableDefinitionMap(meta: R3InjectableMetadata):\n    DefinitionMap<R3DeclareInjectableMetadata> {\n  const definitionMap = new DefinitionMap<R3DeclareInjectableMetadata>();\n\n  definitionMap.set('minVersion', o.literal(MINIMUM_PARTIAL_LINKER_VERSION));\n  definitionMap.set('version', o.literal('0.0.0-PLACEHOLDER'));\n  definitionMap.set('ngImport', o.importExpr(R3.core));\n  definitionMap.set('type', meta.internalType);\n\n  // Only generate providedIn property if it has a non-null value\n  if (meta.providedIn !== undefined) {\n    const providedIn = convertFromProviderExpression(meta.providedIn);\n    if ((providedIn as o.LiteralExpr).value !== null) {\n      definitionMap.set('providedIn', providedIn);\n    }\n  }\n\n  if (meta.useClass !== undefined) {\n    definitionMap.set('useClass', convertFromProviderExpression(meta.useClass));\n  }\n  if (meta.useExisting !== undefined) {\n    definitionMap.set('useExisting', convertFromProviderExpression(meta.useExisting));\n  }\n  if (meta.useValue !== undefined) {\n    definitionMap.set('useValue', convertFromProviderExpression(meta.useValue));\n  }\n  // Factories do not contain `ForwardRef`s since any types are already wrapped in a function call\n  // so the types will not be eagerly evaluated. Therefore we do not need to process this expression\n  // with `convertFromProviderExpression()`.\n  if (meta.useFactory !== undefined) {\n    definitionMap.set('useFactory', meta.useFactory);\n  }\n\n  if (meta.deps !== undefined) {\n    definitionMap.set('deps', o.literalArr(meta.deps.map(compileDependency)));\n  }\n\n  return definitionMap;\n}\n\n/**\n * Convert an `R3ProviderExpression` to an `Expression`, possibly wrapping its expression in a\n * `forwardRef()` call.\n *\n * If `R3ProviderExpression.isForwardRef` is true then the expression was originally wrapped in a\n * `forwardRef()` call to prevent the value from being eagerly evaluated in the code.\n *\n * Normally, the linker will statically process the code, putting the `expression` inside a factory\n * function so the `forwardRef()` wrapper is not evaluated before it has been defined. But if the\n * partial declaration is evaluated by the JIT compiler the `forwardRef()` call is still needed to\n * prevent eager evaluation of the `expression`.\n *\n * So in partial declarations, expressions that could be forward-refs are wrapped in `forwardRef()`\n * calls, and this is then unwrapped in the linker as necessary.\n *\n * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and\n * `packages/compiler/src/jit_compiler_facade.ts` for more information.\n */\nfunction convertFromProviderExpression({expression, isForwardRef}: R3ProviderExpression):\n    o.Expression {\n  return isForwardRef ? generateForwardRef(expression) : expression;\n}\n"]}