static-injector 2.0.0 → 2.1.0

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

@@ -1,11 +1,4 @@
 "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);
@@ -31,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isExpressionFactoryMetadata = exports.isDelegatedFactoryMetadata = exports.createFactoryType = exports.compileFactoryFunction = exports.FactoryTarget = exports.R3FactoryDelegateType = void 0;
-const outputAst = __importStar(require("../output/output_ast"));
+const o = __importStar(require("../output/output_ast"));
 const r3_identifiers_1 = require("../render3/r3_identifiers");
 const util_1 = require("./util");
 var R3FactoryDelegateType;
@@ -51,7 +44,7 @@ var FactoryTarget;
  * Construct a factory function expression for the given `R3FactoryMetadata`.
  */
 function compileFactoryFunction(meta) {
-    const t = outputAst.variable('t');
+    const t = o.variable('t');
     let baseFactoryVar = null;
     // The type to instantiate via constructor invocation. If there is no delegated factory, meaning
     // this type is always created by constructor invocation, then this is the type-to-create
@@ -59,29 +52,29 @@ function compileFactoryFunction(meta) {
     // delegated factory (which is used to create the current type) then this is only the type-to-
     // create parameter (t).
     const typeForCtor = !isDelegatedFactoryMetadata(meta)
-        ? new outputAst.BinaryOperatorExpr(outputAst.BinaryOperator.Or, t, meta.internalType)
+        ? new o.BinaryOperatorExpr(o.BinaryOperator.Or, t, meta.internalType)
         : t;
     let ctorExpr = null;
     if (meta.deps !== null) {
         // There is a constructor (either explicitly or implicitly defined).
         if (meta.deps !== 'invalid') {
-            ctorExpr = new outputAst.InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
+            ctorExpr = new o.InstantiateExpr(typeForCtor, injectDependencies(meta.deps, meta.target));
         }
     }
     else {
         // There is no constructor, use the base class' factory to construct typeForCtor.
-        baseFactoryVar = outputAst.variable(`ɵ${meta.name}_BaseFactory`);
+        baseFactoryVar = o.variable(`ɵ${meta.name}_BaseFactory`);
         ctorExpr = baseFactoryVar.callFn([typeForCtor]);
     }
     const body = [];
     let retExpr = null;
     function makeConditionalFactory(nonCtorExpr) {
-        const r = outputAst.variable('r');
-        body.push(r.set(outputAst.NULL_EXPR).toDeclStmt());
+        const r = o.variable('r');
+        body.push(r.set(o.NULL_EXPR).toDeclStmt());
         const ctorStmt = ctorExpr !== null
             ? r.set(ctorExpr).toStmt()
-            : outputAst.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt();
-        body.push(outputAst.ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
+            : o.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt();
+        body.push(o.ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
         return r;
     }
     if (isDelegatedFactoryMetadata(meta)) {
@@ -90,8 +83,8 @@ function compileFactoryFunction(meta) {
         const delegateArgs = injectDependencies(meta.delegateDeps, meta.target);
         // Either call `new delegate(...)` or `delegate(...)` depending on meta.delegateType.
         const factoryExpr = new (meta.delegateType === R3FactoryDelegateType.Class
-            ? outputAst.InstantiateExpr
-            : outputAst.InvokeFunctionExpr)(meta.delegate, delegateArgs);
+            ? o.InstantiateExpr
+            : o.InvokeFunctionExpr)(meta.delegate, delegateArgs);
         retExpr = makeConditionalFactory(factoryExpr);
     }
     else if (isExpressionFactoryMetadata(meta)) {
@@ -103,29 +96,29 @@ function compileFactoryFunction(meta) {
     }
     if (retExpr === null) {
         // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
-        body.push(outputAst.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt());
+        body.push(o.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt());
     }
     else if (baseFactoryVar !== null) {
         // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
-        const getInheritedFactoryCall = outputAst
+        const getInheritedFactoryCall = o
             .importExpr(r3_identifiers_1.Identifiers.getInheritedFactory)
             .callFn([meta.internalType]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
-        const baseFactory = new outputAst.BinaryOperatorExpr(outputAst.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
-        body.push(new outputAst.ReturnStatement(baseFactory.callFn([typeForCtor])));
+        const baseFactory = new o.BinaryOperatorExpr(o.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
+        body.push(new o.ReturnStatement(baseFactory.callFn([typeForCtor])));
     }
     else {
         // This is straightforward factory, just return it.
-        body.push(new outputAst.ReturnStatement(retExpr));
+        body.push(new o.ReturnStatement(retExpr));
     }
-    let factoryFn = outputAst.fn([new outputAst.FnParam('t', outputAst.DYNAMIC_TYPE)], body, outputAst.INFERRED_TYPE, undefined, `${meta.name}_Factory`);
+    let factoryFn = o.fn([new o.FnParam('t', o.DYNAMIC_TYPE)], body, o.INFERRED_TYPE, undefined, `${meta.name}_Factory`);
     if (baseFactoryVar !== null) {
         // There is a base factory variable so wrap its declaration along with the factory function into
         // an IIFE.
-        factoryFn = outputAst
+        factoryFn = o
             .fn([], [
-            new outputAst.DeclareVarStmt(baseFactoryVar.name),
-            new outputAst.ReturnStatement(factoryFn),
+            new o.DeclareVarStmt(baseFactoryVar.name),
+            new o.ReturnStatement(factoryFn),
         ])
             .callFn([], /* sourceSpan */ undefined, /* pure */ true);
     }
@@ -139,8 +132,8 @@ exports.compileFactoryFunction = compileFactoryFunction;
 function createFactoryType(meta) {
     const ctorDepsType = meta.deps !== null && meta.deps !== 'invalid'
         ? createCtorDepsType(meta.deps)
-        : outputAst.NONE_TYPE;
-    return outputAst.expressionType(outputAst.importExpr(r3_identifiers_1.Identifiers.FactoryDeclaration, [
+        : o.NONE_TYPE;
+    return o.expressionType(o.importExpr(r3_identifiers_1.Identifiers.FactoryDeclaration, [
         (0, util_1.typeWithParameters)(meta.type.type, meta.typeArgumentCount),
         ctorDepsType,
     ]));
@@ -152,29 +145,29 @@ function injectDependencies(deps, target) {
 function compileInjectDependency(dep, target, index) {
     // Interpret the dependency according to its resolved type.
     if (dep.token === null) {
-        return outputAst
-            .importExpr(r3_identifiers_1.Identifiers.invalidFactoryDep)
-            .callFn([outputAst.literal(index)]);
+        return o.importExpr(r3_identifiers_1.Identifiers.invalidFactoryDep).callFn([o.literal(index)]);
     }
     else if (dep.attributeNameType === null) {
         // Build up the injection flags according to the metadata.
         const flags = 0 /* InjectFlags.Default */ |
             (dep.self ? 2 /* InjectFlags.Self */ : 0) |
             (dep.skipSelf ? 4 /* InjectFlags.SkipSelf */ : 0) |
-            (dep.optional ? 8 /* InjectFlags.Optional */ : 0);
+            0 |
+            (dep.optional ? 8 /* InjectFlags.Optional */ : 0) |
+            0;
         // If this dependency is optional or otherwise has non-default flags, then additional
         // parameters describing how to inject the dependency must be passed to the inject function
         // that's being used.
-        let flagsParam = flags !== 0 /* InjectFlags.Default */ || dep.optional
-            ? outputAst.literal(flags)
-            : null;
+        let flagsParam = flags !== 0 /* InjectFlags.Default */ || dep.optional ? o.literal(flags) : null;
         // Build up the arguments to the injectFn call.
         const injectArgs = [dep.token];
         if (flagsParam) {
             injectArgs.push(flagsParam);
         }
         const injectFn = getInjectFn(target);
-        return outputAst.importExpr(injectFn).callFn(injectArgs);
+        return o.importExpr(injectFn).callFn(injectArgs);
+    }
+    else {
     }
 }
 function createCtorDepsType(deps) {
@@ -186,40 +179,28 @@ function createCtorDepsType(deps) {
             return type;
         }
         else {
-            return outputAst.literal(null);
+            return o.literal(null);
         }
     });
     if (hasTypes) {
-        return outputAst.expressionType(outputAst.literalArr(attributeTypes));
+        return o.expressionType(o.literalArr(attributeTypes));
     }
     else {
-        return outputAst.NONE_TYPE;
+        return o.NONE_TYPE;
     }
 }
 function createCtorDepType(dep) {
     const entries = [];
     if (dep.optional) {
-        entries.push({
-            key: 'optional',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'optional', value: o.literal(true), quoted: false });
     }
     if (dep.self) {
-        entries.push({
-            key: 'self',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'self', value: o.literal(true), quoted: false });
     }
     if (dep.skipSelf) {
-        entries.push({
-            key: 'skipSelf',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'skipSelf', value: o.literal(true), quoted: false });
     }
-    return entries.length > 0 ? outputAst.literalMap(entries) : null;
+    return entries.length > 0 ? o.literalMap(entries) : null;
 }
 function isDelegatedFactoryMetadata(meta) {
     return meta.delegateType !== undefined;

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

@@ -6,14 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as o from '../../output/output_ast';
-/**
- * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in
- * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may
- * bot work in some cases when object keys are mangled by minifier.
- *
- * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with
- * inputs that contain potentially unsafe chars.
- */
 /**
  * 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

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

@@ -32,14 +32,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefinitionMap = void 0;
 const o = __importStar(require("../../output/output_ast"));
-/**
- * Checks whether an object key contains potentially unsafe chars, thus the key should be wrapped in
- * quotes. Note: we do not wrap all keys into quotes, as it may have impact on minification and may
- * bot work in some cases when object keys are mangled by minifier.
- *
- * TODO(FW-1136): this is a temporary solution, we need to come up with a better way of working with
- * inputs that contain potentially unsafe chars.
- */
 /**
  * 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

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

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+export * from './src/di';
+export * from './src/factory';
+export * from './src/util';

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

@@ -0,0 +1,26 @@
+"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 __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

@@ -0,0 +1,37 @@
+/**
+ * @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

@@ -0,0 +1,197 @@
+"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 reflection_1 = require("../../../reflection");
+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, reflection_1.Decorator.nodeForError(dec), `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, reflection_1.Decorator.nodeForError(dec), `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 {
+        // TODO(alxhub): this cast is necessary because the g3 typescript version doesn't narrow here.
+        // 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/{src → common/src}/factory.d.ts

@@ -5,7 +5,7 @@
  * 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 "../../../../../compiler";
-import { CompileResult } from "../../transform";
-export declare type CompileFactoryFn = (metadata: R3FactoryMetadata) => CompileResult;
+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/{src → common/src}/factory.js

@@ -8,11 +8,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileNgFactoryDefField = void 0;
-const compiler_1 = require("../../../../../compiler");
+const compiler_1 = require("static-injector/transform/compiler");
 function compileNgFactoryDefField(metadata) {
     const res = (0, compiler_1.compileFactoryFunction)(metadata);
     return {
-        name: "ɵfac",
+        name: 'ɵfac',
         initializer: res.expression,
         statements: res.statements,
         type: res.type,

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

@@ -5,23 +5,9 @@
  * 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, R3DependencyMetadata, R3Reference } from '../../../../../../compiler';
-import { R3FactoryMetadata } from '../../../../../../compiler';
-import { FactoryTarget } from '../../../../../../compiler/src/render3/partial/api';
-import * as ts from 'typescript';
-import { ClassDeclaration, CtorParameter, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference, UnavailableValue } from '../../../reflection';
-export declare 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;
+import { Expression, FactoryTarget, R3FactoryMetadata, R3Reference } from 'static-injector/transform/compiler';
+import ts from 'typescript';
+import { ClassDeclaration, Decorator, Import, ImportedTypeValueReference, LocalTypeValueReference, ReflectionHost, TypeValueReference } from '../../../reflection';
 /**
  * Convert a `TypeValueReference` to an `Expression` which refers to the type as a value.
  *
@@ -31,23 +17,6 @@ export declare function getConstructorDependencies(clazz: ClassDeclaration, refl
  */
 export declare function valueReferenceToExpression(valueRef: LocalTypeValueReference | ImportedTypeValueReference): Expression;
 export declare function valueReferenceToExpression(valueRef: TypeValueReference): Expression | 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;
-/** todo 需要改成自己的依赖包 */
 export declare function isAngularCore(decorator: Decorator): decorator is Decorator & {
     import: Import;
 };