static-injector 1.0.8

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

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

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

@@ -0,0 +1,21 @@
+"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("../../../../../compiler");
+function compileNgFactoryDefField(metadata) {
+    const res = compiler_1.compileFactoryFunction(metadata);
+    return {
+        name: "ɵfac",
+        initializer: res.expression,
+        statements: res.statements,
+        type: res.type,
+    };
+}
+exports.compileNgFactoryDefField = compileNgFactoryDefField;

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

@@ -0,0 +1,42 @@
+/**
+ * @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, R3InjectableMetadata } from '../../../../../compiler';
+import { ClassDeclaration, Decorator, ReflectionHost } from '../../reflection';
+import { AnalysisOutput, CompileResult, DecoratorHandler, DetectResult } from '../../transform';
+interface InjectableHandlerData {
+    meta: R3InjectableMetadata;
+    ctorDeps: R3DependencyMetadata[] | 'invalid' | null;
+}
+/**
+ * Adapts the `compileInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
+ */
+export declare class InjectableDecoratorHandler implements DecoratorHandler<Decorator, InjectableHandlerData, null, unknown> {
+    private reflector;
+    private isCore;
+    private strictCtorDeps;
+    /**
+     * What to do if the injectable already contains a ɵprov property.
+     *
+     * If true then an error diagnostic is reported.
+     * If false then there is no error and a new ɵprov property is not added.
+     */
+    private errorOnDuplicateProv;
+    constructor(reflector: ReflectionHost, isCore: boolean, strictCtorDeps: boolean, 
+    /**
+     * What to do if the injectable already contains a ɵprov property.
+     *
+     * If true then an error diagnostic is reported.
+     * If false then there is no error and a new ɵprov property is not added.
+     */
+    errorOnDuplicateProv?: boolean);
+    detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator> | undefined;
+    analyze(node: ClassDeclaration, decorator: Readonly<Decorator>): AnalysisOutput<InjectableHandlerData>;
+    compileFull(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];
+    private compile;
+}
+export {};

package/transform/compiler-cli/src/ngtsc/annotations/src/injectable.js

@@ -0,0 +1,278 @@
+"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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.InjectableDecoratorHandler = void 0;
+const compiler_1 = require("../../../../../compiler");
+const ts = __importStar(require("typescript"));
+const diagnostics_1 = require("../../diagnostics");
+const reflection_1 = require("../../reflection");
+const factory_1 = require("./factory");
+const util_1 = require("./util");
+/**
+ * Adapts the `compileInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
+ */
+class InjectableDecoratorHandler {
+    constructor(reflector, isCore, strictCtorDeps, 
+    /**
+     * What to do if the injectable already contains a ɵprov property.
+     *
+     * If true then an error diagnostic is reported.
+     * If false then there is no error and a new ɵprov property is not added.
+     */
+    errorOnDuplicateProv = true) {
+        this.reflector = reflector;
+        this.isCore = isCore;
+        this.strictCtorDeps = strictCtorDeps;
+        this.errorOnDuplicateProv = errorOnDuplicateProv;
+    }
+    detect(node, decorators) {
+        if (!decorators) {
+            return undefined;
+        }
+        const decorator = util_1.findAngularDecorator(decorators, 'Injectable', this.isCore);
+        if (decorator !== undefined) {
+            return {
+                trigger: decorator.node,
+                decorator: decorator,
+                metadata: decorator,
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    analyze(node, decorator) {
+        const meta = extractInjectableMetadata(node, decorator, this.reflector);
+        return {
+            analysis: {
+                meta,
+                ctorDeps: extractInjectableCtorDeps(node, meta, decorator, this.reflector, this.isCore, this.strictCtorDeps),
+                // Avoid generating multiple factories if a class has
+                // more Angular decorators, apart from Injectable.
+            },
+        };
+    }
+    compileFull(node, analysis) {
+        return this.compile(factory_1.compileNgFactoryDefField, (meta) => compiler_1.compileInjectable(meta, false), node, analysis);
+    }
+    compile(compileFactoryFn, compileInjectableFn, node, analysis) {
+        const results = [];
+        const meta = analysis.meta;
+        const factoryRes = compileFactoryFn(util_1.toFactoryMetadata(Object.assign(Object.assign({}, meta), { deps: analysis.ctorDeps }), compiler_1.FactoryTarget.Injectable));
+        results.push(factoryRes);
+        const ɵprov = this.reflector
+            .getMembersOfClass(node)
+            .find((member) => member.name === 'ɵprov');
+        if (ɵprov !== undefined && this.errorOnDuplicateProv) {
+            throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.INJECTABLE_DUPLICATE_PROV, ɵprov.nameNode || ɵprov.node || node, 'Injectables cannot contain a static ɵprov property, because the compiler is going to generate one.');
+        }
+        if (ɵprov === undefined) {
+            // Only add a new ɵprov if there is not one already
+            const res = compileInjectableFn(analysis.meta);
+            results.push({
+                name: 'ɵprov',
+                initializer: res.expression,
+                statements: res.statements,
+                type: res.type,
+            });
+        }
+        return results;
+    }
+}
+exports.InjectableDecoratorHandler = InjectableDecoratorHandler;
+/**
+ * Read metadata from the `@Injectable` decorator and produce the `IvyInjectableMetadata`, the
+ * input metadata needed to run `compileInjectable`.
+ *
+ * A `null` return value indicates this is @Injectable has invalid data.
+ */
+function extractInjectableMetadata(clazz, decorator, reflector) {
+    const name = clazz.name.text;
+    const type = util_1.wrapTypeReference(reflector, clazz);
+    const internalType = new compiler_1.WrappedNodeExpr(reflector.getInternalNameOfClass(clazz));
+    const typeArgumentCount = reflector.getGenericArityOfClass(clazz) || 0;
+    if (decorator.args === null) {
+        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, reflection_1.Decorator.nodeForError(decorator), '@Injectable must be called');
+    }
+    if (decorator.args.length === 0) {
+        return {
+            name,
+            type,
+            typeArgumentCount,
+            internalType,
+            providedIn: compiler_1.createR3ProviderExpression(new compiler_1.LiteralExpr(null), false),
+        };
+    }
+    else if (decorator.args.length === 1) {
+        const metaNode = decorator.args[0];
+        // Firstly make sure the decorator argument is an inline literal - if not, it's illegal to
+        // transport references from one location to another. This is the problem that lowering
+        // used to solve - if this restriction proves too undesirable we can re-implement lowering.
+        if (!ts.isObjectLiteralExpression(metaNode)) {
+            throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARG_NOT_LITERAL, metaNode, `@Injectable argument must be an object literal`);
+        }
+        // Resolve the fields of the literal into a map of field name to expression.
+        const meta = reflection_1.reflectObjectLiteral(metaNode);
+        const providedIn = meta.has('providedIn')
+            ? getProviderExpression(meta.get('providedIn'), reflector)
+            : compiler_1.createR3ProviderExpression(new compiler_1.LiteralExpr(null), false);
+        let deps = undefined;
+        if ((meta.has('useClass') || meta.has('useFactory')) && meta.has('deps')) {
+            const depsExpr = meta.get('deps');
+            if (!ts.isArrayLiteralExpression(depsExpr)) {
+                throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.VALUE_NOT_LITERAL, depsExpr, `@Injectable deps metadata must be an inline array`);
+            }
+            deps = depsExpr.elements.map((dep) => getDep(dep, reflector));
+        }
+        const result = {
+            name,
+            type,
+            typeArgumentCount,
+            internalType,
+            providedIn,
+        };
+        if (meta.has('useValue')) {
+            result.useValue = getProviderExpression(meta.get('useValue'), reflector);
+        }
+        else if (meta.has('useExisting')) {
+            result.useExisting = getProviderExpression(meta.get('useExisting'), reflector);
+        }
+        else if (meta.has('useClass')) {
+            result.useClass = getProviderExpression(meta.get('useClass'), reflector);
+            result.deps = deps;
+        }
+        else if (meta.has('useFactory')) {
+            result.useFactory = new compiler_1.WrappedNodeExpr(meta.get('useFactory'));
+            result.deps = deps;
+        }
+        return result;
+    }
+    else {
+        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, decorator.args[2], 'Too many arguments to @Injectable');
+    }
+}
+/**
+ * Get the `R3ProviderExpression` for this `expression`.
+ *
+ * The `useValue`, `useExisting` and `useClass` properties might be wrapped in a `ForwardRef`, which
+ * needs to be unwrapped. This function will do that unwrapping and set a flag on the returned
+ * object to indicate whether the value needed unwrapping.
+ */
+function getProviderExpression(expression, reflector) {
+    const forwardRefValue = util_1.tryUnwrapForwardRef(expression, reflector);
+    return compiler_1.createR3ProviderExpression(new compiler_1.WrappedNodeExpr(forwardRefValue !== null && forwardRefValue !== void 0 ? forwardRefValue : expression), forwardRefValue !== null);
+}
+function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, strictCtorDeps) {
+    if (decorator.args === null) {
+        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, reflection_1.Decorator.nodeForError(decorator), '@Injectable must be called');
+    }
+    let ctorDeps = null;
+    if (decorator.args.length === 0) {
+        // Ideally, using @Injectable() would have the same effect as using @Injectable({...}), and be
+        // subject to the same validation. However, existing Angular code abuses @Injectable, applying
+        // it to things like abstract classes with constructors that were never meant for use with
+        // Angular's DI.
+        //
+        // To deal with this, @Injectable() without an argument is more lenient, and if the
+        // constructor signature does not work for DI then a factory definition (ɵfac) that throws is
+        // generated.
+        if (strictCtorDeps) {
+            ctorDeps = util_1.getValidConstructorDependencies(clazz, reflector, isCore);
+        }
+        else {
+            ctorDeps = util_1.unwrapConstructorDependencies(util_1.getConstructorDependencies(clazz, reflector, isCore));
+        }
+        return ctorDeps;
+    }
+    else if (decorator.args.length === 1) {
+        const rawCtorDeps = util_1.getConstructorDependencies(clazz, reflector, isCore);
+        if (strictCtorDeps &&
+            meta.useValue === undefined &&
+            meta.useExisting === undefined &&
+            meta.useClass === undefined &&
+            meta.useFactory === undefined) {
+            // Since use* was not provided, validate the deps according to strictCtorDeps.
+            ctorDeps = util_1.validateConstructorDependencies(clazz, rawCtorDeps);
+        }
+        else {
+            ctorDeps = util_1.unwrapConstructorDependencies(rawCtorDeps);
+        }
+    }
+    return ctorDeps;
+}
+function getDep(dep, reflector) {
+    const meta = {
+        token: new compiler_1.WrappedNodeExpr(dep),
+        attributeNameType: null,
+        optional: false,
+        self: false,
+        skipSelf: false,
+    };
+    function maybeUpdateDecorator(dec, reflector, token) {
+        const source = reflector.getImportOfIdentifier(dec);
+        if (source === null || source.from !== 'static-injector') {
+            return false;
+        }
+        switch (source.name) {
+            case 'Inject':
+                if (token !== undefined) {
+                    meta.token = new compiler_1.WrappedNodeExpr(token);
+                }
+                break;
+            case 'Optional':
+                meta.optional = true;
+                break;
+            case 'SkipSelf':
+                meta.skipSelf = true;
+                break;
+            case 'Self':
+                meta.self = true;
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+    if (ts.isArrayLiteralExpression(dep)) {
+        dep.elements.forEach((el) => {
+            let isParametersDecorator = false;
+            if (ts.isIdentifier(el)) {
+                isParametersDecorator = maybeUpdateDecorator(el, reflector);
+            }
+            else if (ts.isNewExpression(el) && ts.isIdentifier(el.expression)) {
+                const token = (el.arguments && el.arguments.length > 0 && el.arguments[0]) ||
+                    undefined;
+                isParametersDecorator = maybeUpdateDecorator(el.expression, reflector, token);
+            }
+            if (!isParametersDecorator) {
+                meta.token = new compiler_1.WrappedNodeExpr(el);
+            }
+        });
+    }
+    return meta;
+}

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

@@ -0,0 +1,91 @@
+/**
+ * @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, 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;
+/**
+ * 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;
+/**
+ * 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;
+};
+export declare function findAngularDecorator(decorators: Decorator[], name: string, isCore: boolean): Decorator | undefined;
+export declare function isAngularDecorator(decorator: Decorator, name: string, isCore: boolean): boolean;
+/**
+ * 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 by ngcc 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;