static-injector 4.0.1 → 5.0.0-alpha.0

package/transform/compiler/src/render3/r3_identifiers.js

@@ -1,55 +0,0 @@
-"use strict";
-/**
- * @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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Identifiers = void 0;
-const CORE = 'static-injector';
-class Identifiers {
-    /* Methods */
-    /* Instructions */
-    static inject = { name: 'ɵɵinject', moduleName: CORE };
-    static directiveInject = {
-        name: 'ɵɵdirectiveInject',
-        moduleName: CORE,
-    };
-    static invalidFactory = {
-        name: 'ɵɵinvalidFactory',
-        moduleName: CORE,
-    };
-    static invalidFactoryDep = {
-        name: 'ɵɵinvalidFactoryDep',
-        moduleName: CORE,
-    };
-    static forwardRef = {
-        name: 'forwardRef',
-        moduleName: CORE,
-    };
-    static resolveForwardRef = {
-        name: 'resolveForwardRef',
-        moduleName: CORE,
-    };
-    static ɵɵdefineInjectable = {
-        name: 'ɵɵdefineInjectable',
-        moduleName: CORE,
-    };
-    static InjectableDeclaration = {
-        name: 'ɵɵInjectableDeclaration',
-        moduleName: CORE,
-    };
-    static FactoryDeclaration = {
-        name: 'ɵɵFactoryDeclaration',
-        moduleName: CORE,
-    };
-    // Signal queries
-    // Two-way bindings
-    static getInheritedFactory = {
-        name: 'ɵɵgetInheritedFactory',
-        moduleName: CORE,
-    };
-}
-exports.Identifiers = Identifiers;

package/transform/compiler/src/render3/util.d.ts

@@ -1,85 +0,0 @@
-/**
- * @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 * as o from '../output/output_ast';
-export declare function typeWithParameters(type: o.Expression, numParams: number): o.ExpressionType;
-export interface R3Reference {
-    value: o.Expression;
-    type: o.Expression;
-}
-/**
- * Result of compilation of a render3 code unit, e.g. component, directive, pipe, etc.
- */
-export interface R3CompiledExpression {
-    expression: o.Expression;
-    type: o.Type;
-    statements: o.Statement[];
-}
-/**
- * Describes an expression that may have been wrapped in a `forwardRef()` guard.
- *
- * This is used when describing expressions that can refer to types that may eagerly reference types
- * that have not yet been defined.
- */
-export interface MaybeForwardRefExpression<T extends o.Expression = o.Expression> {
-    /**
-     * The unwrapped expression.
-     */
-    expression: T;
-    /**
-     * Specified whether the `expression` contains a reference to something that has not yet been
-     * defined, and whether the expression is still wrapped in a `forwardRef()` call.
-     *
-     * If this value is `ForwardRefHandling.None` then the `expression` is safe to use as-is.
-     *
-     * Otherwise the `expression` was wrapped in a call to `forwardRef()` and must not be eagerly
-     * evaluated. Instead it must be wrapped in a function closure that will be evaluated lazily to
-     * allow the definition of the expression to be evaluated first.
-     *
-     * In full AOT compilation it can be safe to unwrap the `forwardRef()` call up front if the
-     * expression will actually be evaluated lazily inside a function call after the value of
-     * `expression` has been defined.
-     *
-     * But in other cases, such as partial AOT compilation or JIT compilation the expression will be
-     * evaluated eagerly in top level code so will need to continue to be wrapped in a `forwardRef()`
-     * call.
-     *
-     */
-    forwardRef: ForwardRefHandling;
-}
-export declare function createMayBeForwardRefExpression<T extends o.Expression>(expression: T, forwardRef: ForwardRefHandling): MaybeForwardRefExpression<T>;
-/**
- * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
- * `forwardRef()` call.
- *
- * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
- * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
- * in the code.
- *
- * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
- * `packages/compiler/src/jit_compiler_facade.ts` for more information.
- */
-export declare function convertFromMaybeForwardRefExpression({ expression, forwardRef, }: MaybeForwardRefExpression): o.Expression;
-/**
- * Generate an expression that has the given `expr` wrapped in the following form:
- *
- * ```
- * forwardRef(() => expr)
- * ```
- */
-export declare function generateForwardRef(expr: o.Expression): o.Expression;
-/**
- * Specifies how a forward ref has been handled in a MaybeForwardRefExpression
- */
-export declare const enum ForwardRefHandling {
-    /** The expression was not wrapped in a `forwardRef()` call in the first place. */
-    None = 0,
-    /** The expression is still wrapped in a `forwardRef()` call. */
-    Wrapped = 1,
-    /** The expression was wrapped in a `forwardRef()` call but has since been unwrapped. */
-    Unwrapped = 2
-}

package/transform/compiler/src/render3/util.js

@@ -1,82 +0,0 @@
-"use strict";
-/**
- * @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
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateForwardRef = exports.convertFromMaybeForwardRefExpression = exports.createMayBeForwardRefExpression = exports.typeWithParameters = void 0;
-const o = __importStar(require("../output/output_ast"));
-const r3_identifiers_1 = require("./r3_identifiers");
-function typeWithParameters(type, numParams) {
-    if (numParams === 0) {
-        return o.expressionType(type);
-    }
-    const params = [];
-    for (let i = 0; i < numParams; i++) {
-        params.push(o.DYNAMIC_TYPE);
-    }
-    return o.expressionType(type, undefined, params);
-}
-exports.typeWithParameters = typeWithParameters;
-function createMayBeForwardRefExpression(expression, forwardRef) {
-    return { expression, forwardRef };
-}
-exports.createMayBeForwardRefExpression = createMayBeForwardRefExpression;
-/**
- * Convert a `MaybeForwardRefExpression` to an `Expression`, possibly wrapping its expression in a
- * `forwardRef()` call.
- *
- * If `MaybeForwardRefExpression.forwardRef` is `ForwardRefHandling.Unwrapped` then the expression
- * was originally wrapped in a `forwardRef()` call to prevent the value from being eagerly evaluated
- * in the code.
- *
- * See `packages/compiler-cli/src/ngtsc/annotations/src/injectable.ts` and
- * `packages/compiler/src/jit_compiler_facade.ts` for more information.
- */
-function convertFromMaybeForwardRefExpression({ expression, forwardRef, }) {
-    switch (forwardRef) {
-        case 0 /* ForwardRefHandling.None */:
-        case 1 /* ForwardRefHandling.Wrapped */:
-            return expression;
-        case 2 /* ForwardRefHandling.Unwrapped */:
-            return generateForwardRef(expression);
-    }
-}
-exports.convertFromMaybeForwardRefExpression = convertFromMaybeForwardRefExpression;
-/**
- * Generate an expression that has the given `expr` wrapped in the following form:
- *
- * ```
- * forwardRef(() => expr)
- * ```
- */
-function generateForwardRef(expr) {
-    return o.importExpr(r3_identifiers_1.Identifiers.forwardRef).callFn([o.arrowFn([], expr)]);
-}
-exports.generateForwardRef = generateForwardRef;

package/transform/compiler/src/render3/view/util.d.ts

@@ -1,24 +0,0 @@
-/**
- * @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 * as o from '../../output/output_ast';
-/** Special value representing a direct access to a template's context. */
-export declare const DIRECT_CONTEXT_REFERENCE = "#context";
-/**
- * A representation for an object literal used during codegen of definition objects. The generic
- * type `T` allows to reference a documented type of the generated structure, such that the
- * property names that are set can be resolved to their documented declaration.
- */
-export declare class DefinitionMap<T = any> {
-    values: {
-        key: string;
-        quoted: boolean;
-        value: o.Expression;
-    }[];
-    set(key: keyof T, value: o.Expression | null): void;
-    toLiteralMap(): o.LiteralMapExpr;
-}

package/transform/compiler/src/render3/view/util.js

@@ -1,59 +0,0 @@
-"use strict";
-/**
- * @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
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefinitionMap = exports.DIRECT_CONTEXT_REFERENCE = void 0;
-const o = __importStar(require("../../output/output_ast"));
-/** Special value representing a direct access to a template's context. */
-exports.DIRECT_CONTEXT_REFERENCE = '#context';
-/**
- * A representation for an object literal used during codegen of definition objects. The generic
- * type `T` allows to reference a documented type of the generated structure, such that the
- * property names that are set can be resolved to their documented declaration.
- */
-class DefinitionMap {
-    values = [];
-    set(key, value) {
-        if (value) {
-            const existing = this.values.find((value) => value.key === key);
-            if (existing) {
-                existing.value = value;
-            }
-            else {
-                this.values.push({ key: key, value, quoted: false });
-            }
-        }
-    }
-    toLiteralMap() {
-        return o.literalMap(this.values);
-    }
-}
-exports.DefinitionMap = DefinitionMap;

package/transform/compiler-cli/src/ngtsc/annotations/common/index.d.ts

@@ -1,3 +0,0 @@
-export * from './src/di';
-export * from './src/factory';
-export * from './src/util';

package/transform/compiler-cli/src/ngtsc/annotations/common/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/di"), exports);
-__exportStar(require("./src/factory"), exports);
-__exportStar(require("./src/util"), exports);

package/transform/compiler-cli/src/ngtsc/annotations/common/src/di.d.ts

@@ -1,37 +0,0 @@
-/**
- * @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 { R3DependencyMetadata } from 'static-injector/transform/compiler';
-import { ClassDeclaration, CtorParameter, ReflectionHost, UnavailableValue } from '../../../reflection';
-export type ConstructorDeps = {
-    deps: R3DependencyMetadata[];
-} | {
-    deps: null;
-    errors: ConstructorDepError[];
-};
-export interface ConstructorDepError {
-    index: number;
-    param: CtorParameter;
-    reason: UnavailableValue;
-}
-export declare function getConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): ConstructorDeps | null;
-/**
- * Convert `ConstructorDeps` into the `R3DependencyMetadata` array for those deps if they're valid,
- * or into an `'invalid'` signal if they're not.
- *
- * This is a companion function to `validateConstructorDependencies` which accepts invalid deps.
- */
-export declare function unwrapConstructorDependencies(deps: ConstructorDeps | null): R3DependencyMetadata[] | 'invalid' | null;
-export declare function getValidConstructorDependencies(clazz: ClassDeclaration, reflector: ReflectionHost, isCore: boolean): R3DependencyMetadata[] | null;
-/**
- * Validate that `ConstructorDeps` does not have any invalid dependencies and convert them into the
- * `R3DependencyMetadata` array if so, or raise a diagnostic if some deps are invalid.
- *
- * This is a companion function to `unwrapConstructorDependencies` which does not accept invalid
- * deps.
- */
-export declare function validateConstructorDependencies(clazz: ClassDeclaration, deps: ConstructorDeps | null): R3DependencyMetadata[] | null;

package/transform/compiler-cli/src/ngtsc/annotations/common/src/di.js

@@ -1,195 +0,0 @@
-"use strict";
-/**
- * @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
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateConstructorDependencies = exports.getValidConstructorDependencies = exports.unwrapConstructorDependencies = exports.getConstructorDependencies = void 0;
-const compiler_1 = require("static-injector/transform/compiler");
-const typescript_1 = __importDefault(require("typescript"));
-const diagnostics_1 = require("../../../diagnostics");
-const util_1 = require("./util");
-function getConstructorDependencies(clazz, reflector, isCore) {
-    const deps = [];
-    const errors = [];
-    let ctorParams = reflector.getConstructorParameters(clazz);
-    if (ctorParams === null) {
-        if (reflector.hasBaseClass(clazz)) {
-            return null;
-        }
-        else {
-            ctorParams = [];
-        }
-    }
-    ctorParams.forEach((param, idx) => {
-        let token = (0, util_1.valueReferenceToExpression)(param.typeValueReference);
-        let attributeNameType = null;
-        let optional = false, self = false, skipSelf = false, host = false;
-        (param.decorators || [])
-            .filter((dec) => isCore || (0, util_1.isAngularCore)(dec))
-            .forEach((dec) => {
-            const name = isCore || dec.import === null ? dec.name : dec.import.name;
-            if (name === 'Inject') {
-                if (dec.args === null || dec.args.length !== 1) {
-                    throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, dec.node, `Unexpected number of arguments to @Inject().`);
-                }
-                token = new compiler_1.WrappedNodeExpr(dec.args[0]);
-            }
-            else if (name === 'Optional') {
-                optional = true;
-            }
-            else if (name === 'SkipSelf') {
-                skipSelf = true;
-            }
-            else if (name === 'Self') {
-                self = true;
-            }
-            else if (name === 'Host') {
-            }
-            else if (name === 'Attribute') {
-            }
-            else {
-                throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_UNEXPECTED, dec.node, `Unexpected decorator ${name} on parameter.`);
-            }
-        });
-        if (token === null) {
-            if (param.typeValueReference.kind !== 2 /* TypeValueReferenceKind.UNAVAILABLE */) {
-                throw new Error('Illegal state: expected value reference to be unavailable if no token is present');
-            }
-            errors.push({
-                index: idx,
-                param,
-                reason: param.typeValueReference.reason,
-            });
-        }
-        else {
-            deps.push({ token, attributeNameType, optional, self, skipSelf });
-        }
-    });
-    if (errors.length === 0) {
-        return { deps };
-    }
-    else {
-        return { deps: null, errors };
-    }
-}
-exports.getConstructorDependencies = getConstructorDependencies;
-/**
- * Convert `ConstructorDeps` into the `R3DependencyMetadata` array for those deps if they're valid,
- * or into an `'invalid'` signal if they're not.
- *
- * This is a companion function to `validateConstructorDependencies` which accepts invalid deps.
- */
-function unwrapConstructorDependencies(deps) {
-    if (deps === null) {
-        return null;
-    }
-    else if (deps.deps !== null) {
-        // These constructor dependencies are valid.
-        return deps.deps;
-    }
-    else {
-        // These deps are invalid.
-        return 'invalid';
-    }
-}
-exports.unwrapConstructorDependencies = unwrapConstructorDependencies;
-function getValidConstructorDependencies(clazz, reflector, isCore) {
-    return validateConstructorDependencies(clazz, getConstructorDependencies(clazz, reflector, isCore));
-}
-exports.getValidConstructorDependencies = getValidConstructorDependencies;
-/**
- * Validate that `ConstructorDeps` does not have any invalid dependencies and convert them into the
- * `R3DependencyMetadata` array if so, or raise a diagnostic if some deps are invalid.
- *
- * This is a companion function to `unwrapConstructorDependencies` which does not accept invalid
- * deps.
- */
-function validateConstructorDependencies(clazz, deps) {
-    if (deps === null) {
-        return null;
-    }
-    else if (deps.deps !== null) {
-        return deps.deps;
-    }
-    else {
-        // There is at least one error.
-        const error = deps.errors[0];
-        throw createUnsuitableInjectionTokenError(clazz, error);
-    }
-}
-exports.validateConstructorDependencies = validateConstructorDependencies;
-/**
- * Creates a fatal error with diagnostic for an invalid injection token.
- * @param clazz The class for which the injection token was unavailable.
- * @param error The reason why no valid injection token is available.
- */
-function createUnsuitableInjectionTokenError(clazz, error) {
-    const { param, index, reason } = error;
-    let chainMessage = undefined;
-    let hints = undefined;
-    switch (reason.kind) {
-        case 5 /* ValueUnavailableKind.UNSUPPORTED */:
-            chainMessage =
-                'Consider using the @Inject decorator to specify an injection token.';
-            hints = [
-                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type is not supported as injection token.'),
-            ];
-            break;
-        case 1 /* ValueUnavailableKind.NO_VALUE_DECLARATION */:
-            chainMessage =
-                'Consider using the @Inject decorator to specify an injection token.';
-            hints = [
-                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type does not have a value, so it cannot be used as injection token.'),
-            ];
-            if (reason.decl !== null) {
-                hints.push((0, diagnostics_1.makeRelatedInformation)(reason.decl, 'The type is declared here.'));
-            }
-            break;
-        case 2 /* ValueUnavailableKind.TYPE_ONLY_IMPORT */:
-            chainMessage =
-                'Consider changing the type-only import to a regular import, or use the @Inject decorator to specify an injection token.';
-            hints = [
-                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type is imported using a type-only import, which prevents it from being usable as an injection token.'),
-                (0, diagnostics_1.makeRelatedInformation)(reason.node, 'The type-only import occurs here.'),
-            ];
-            break;
-        case 4 /* ValueUnavailableKind.NAMESPACE */:
-            chainMessage =
-                'Consider using the @Inject decorator to specify an injection token.';
-            hints = [
-                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type corresponds with a namespace, which cannot be used as injection token.'),
-                (0, diagnostics_1.makeRelatedInformation)(reason.importClause, 'The namespace import occurs here.'),
-            ];
-            break;
-        case 3 /* ValueUnavailableKind.UNKNOWN_REFERENCE */:
-            chainMessage = 'The type should reference a known declaration.';
-            hints = [
-                (0, diagnostics_1.makeRelatedInformation)(reason.typeNode, 'This type could not be resolved.'),
-            ];
-            break;
-        case 0 /* ValueUnavailableKind.MISSING_TYPE */:
-            chainMessage =
-                'Consider adding a type to the parameter or use the @Inject decorator to specify an injection token.';
-            break;
-    }
-    const chain = {
-        messageText: `No suitable injection token for parameter '${param.name || index}' of class '${clazz.name.text}'.`,
-        category: typescript_1.default.DiagnosticCategory.Error,
-        code: 0,
-        next: [
-            {
-                messageText: chainMessage,
-                category: typescript_1.default.DiagnosticCategory.Message,
-                code: 0,
-            },
-        ],
-    };
-    return new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.PARAM_MISSING_TOKEN, param.nameNode, chain, hints);
-}

package/transform/compiler-cli/src/ngtsc/annotations/common/src/factory.d.ts

@@ -1,11 +0,0 @@
-/**
- * @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 { R3FactoryMetadata } from 'static-injector/transform/compiler';
-import { CompileResult } from '../../../transform';
-export type CompileFactoryFn = (metadata: R3FactoryMetadata) => CompileResult;
-export declare function compileNgFactoryDefField(metadata: R3FactoryMetadata): CompileResult;

package/transform/compiler-cli/src/ngtsc/annotations/common/src/factory.js

@@ -1,22 +0,0 @@
-"use strict";
-/**
- * @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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileNgFactoryDefField = void 0;
-const compiler_1 = require("static-injector/transform/compiler");
-function compileNgFactoryDefField(metadata) {
-    const res = (0, compiler_1.compileFactoryFunction)(metadata);
-    return {
-        name: 'ɵfac',
-        initializer: res.expression,
-        statements: res.statements,
-        type: res.type,
-        deferrableImports: null,
-    };
-}
-exports.compileNgFactoryDefField = compileNgFactoryDefField;

package/transform/compiler-cli/src/ngtsc/annotations/common/src/util.d.ts

@@ -1,64 +0,0 @@
-/**
- * @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 { Expression, FactoryTarget, R3FactoryMetadata, R3Reference } from 'static-injector/transform/compiler';
-import ts from 'typescript';
-import { ClassDeclaration, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference } from '../../../reflection';
-/** Module name of the framework core. */
-export declare const CORE_MODULE = "static-injector";
-/**
- * Convert a `TypeValueReference` to an `Expression` which refers to the type as a value.
- *
- * Local references are converted to a `WrappedNodeExpr` of the TypeScript expression, and non-local
- * references are converted to an `ExternalExpr`. Note that this is only valid in the context of the
- * file in which the `TypeValueReference` originated.
- */
-export declare function valueReferenceToExpression(valueRef: LocalTypeValueReference | ImportedTypeValueReference): Expression;
-export declare function valueReferenceToExpression(valueRef: TypeValueReference): Expression | null;
-export declare function isAngularCore(decorator: Decorator): decorator is Decorator & {
-    import: Import;
-};
-export declare function findAngularDecorator(decorators: Decorator[], name: string, isCore: boolean): Decorator | undefined;
-export declare function isAngularDecorator(decorator: Decorator, name: string, isCore: boolean): boolean;
-export declare function getAngularDecorators(decorators: Decorator[], names: readonly string[], isCore: boolean): Decorator[];
-/**
- * Unwrap a `ts.Expression`, removing outer type-casts or parentheses until the expression is in its
- * lowest level form.
- *
- * For example, the expression "(foo as Type)" unwraps to "foo".
- */
-export declare function unwrapExpression(node: ts.Expression): ts.Expression;
-/**
- * If the given `node` is a forwardRef() expression then resolve its inner value, otherwise return
- * `null`.
- *
- * @param node the forwardRef() expression to resolve
- * @param reflector a ReflectionHost
- * @returns the resolved expression, if the original expression was a forwardRef(), or `null`
- *     otherwise.
- */
-export declare function tryUnwrapForwardRef(node: ts.Expression, reflector: ReflectionHost): ts.Expression | null;
-/**
- * Wraps all functions in a given expression in parentheses. This is needed to avoid problems
- * where Tsickle annotations added between analyse and transform phases in Angular may trigger
- * automatic semicolon insertion, e.g. if a function is the expression in a `return` statement.
- * More
- * info can be found in Tsickle source code here:
- * https://github.com/angular/tsickle/blob/d7974262571c8a17d684e5ba07680e1b1993afdd/src/jsdoc_transformer.ts#L1021
- *
- * @param expression Expression where functions should be wrapped in parentheses
- */
-export declare function wrapFunctionExpressionsInParens(expression: ts.Expression): ts.Expression;
-/**
- * Create an R3Reference for a class.
- *
- * The `value` is the exported declaration of the class from its source file.
- * The `type` is an expression that would be used in the typings (.d.ts) files.
- */
-export declare function wrapTypeReference(reflector: ReflectionHost, clazz: ClassDeclaration): R3Reference;
-export declare function toFactoryMetadata(meta: Omit<R3FactoryMetadata, 'target'>, target: FactoryTarget): R3FactoryMetadata;
-export declare function isAbstractClassDeclaration(clazz: ClassDeclaration): boolean;