static-injector 4.0.2 → 5.0.0-alpha.0

package/transform/compiler-cli/src/ngtsc/reflection/src/typescript.js

@@ -1,393 +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.getContainingImportDeclaration = exports.reflectObjectLiteral = exports.TypeScriptReflectionHost = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const host_1 = require("./host");
-const type_to_value_1 = require("./type_to_value");
-const util_1 = require("./util");
-/**
- * reflector.ts implements static reflection of declarations using the TypeScript `ts.TypeChecker`.
- */
-class TypeScriptReflectionHost {
-    checker;
-    isLocalCompilation;
-    constructor(checker, isLocalCompilation = false) {
-        this.checker = checker;
-        this.isLocalCompilation = isLocalCompilation;
-    }
-    getDecoratorsOfDeclaration(declaration) {
-        const decorators = typescript_1.default.canHaveDecorators(declaration)
-            ? typescript_1.default.getDecorators(declaration)
-            : undefined;
-        return decorators !== undefined && decorators.length
-            ? decorators
-                .map((decorator) => this._reflectDecorator(decorator))
-                .filter((dec) => dec !== null)
-            : null;
-    }
-    getMembersOfClass(clazz) {
-        const tsClazz = castDeclarationToClassOrDie(clazz);
-        return tsClazz.members
-            .map((member) => this._reflectMember(member))
-            .filter((member) => member !== null);
-    }
-    getConstructorParameters(clazz) {
-        const tsClazz = castDeclarationToClassOrDie(clazz);
-        const isDeclaration = tsClazz.getSourceFile().isDeclarationFile;
-        // For non-declaration files, we want to find the constructor with a `body`. The constructors
-        // without a `body` are overloads whereas we want the implementation since it's the one that'll
-        // be executed and which can have decorators. For declaration files, we take the first one that
-        // we get.
-        const ctor = tsClazz.members.find((member) => typescript_1.default.isConstructorDeclaration(member) &&
-            (isDeclaration || member.body !== undefined));
-        if (ctor === undefined) {
-            return null;
-        }
-        return ctor.parameters.map((node) => {
-            // The name of the parameter is easy.
-            const name = parameterName(node.name);
-            const decorators = this.getDecoratorsOfDeclaration(node);
-            // It may or may not be possible to write an expression that refers to the value side of the
-            // type named for the parameter.
-            let originalTypeNode = node.type || null;
-            let typeNode = originalTypeNode;
-            // Check if we are dealing with a simple nullable union type e.g. `foo: Foo|null`
-            // and extract the type. More complex union types e.g. `foo: Foo|Bar` are not supported.
-            // We also don't need to support `foo: Foo|undefined` because Angular's DI injects `null` for
-            // optional tokes that don't have providers.
-            if (typeNode && typescript_1.default.isUnionTypeNode(typeNode)) {
-                let childTypeNodes = typeNode.types.filter((childTypeNode) => !(typescript_1.default.isLiteralTypeNode(childTypeNode) &&
-                    childTypeNode.literal.kind === typescript_1.default.SyntaxKind.NullKeyword));
-                if (childTypeNodes.length === 1) {
-                    typeNode = childTypeNodes[0];
-                }
-            }
-            const typeValueReference = (0, type_to_value_1.typeToValue)(typeNode, this.checker, this.isLocalCompilation);
-            return {
-                name,
-                nameNode: node.name,
-                typeValueReference,
-                typeNode: originalTypeNode,
-                decorators,
-            };
-        });
-    }
-    getImportOfIdentifier(id) {
-        const directImport = this.getDirectImportOfIdentifier(id);
-        if (directImport !== null) {
-            return directImport;
-        }
-        else if (typescript_1.default.isQualifiedName(id.parent) && id.parent.right === id) {
-            return this.getImportOfNamespacedIdentifier(id, getQualifiedNameRoot(id.parent));
-        }
-        else if (typescript_1.default.isPropertyAccessExpression(id.parent) &&
-            id.parent.name === id) {
-            return this.getImportOfNamespacedIdentifier(id, getFarLeftIdentifier(id.parent));
-        }
-        else {
-            return null;
-        }
-    }
-    isClass(node) {
-        // For our purposes, classes are "named" ts.ClassDeclarations;
-        // (`node.name` can be undefined in unnamed default exports: `default export class { ... }`).
-        return (0, util_1.isNamedClassDeclaration)(node);
-    }
-    hasBaseClass(clazz) {
-        return this.getBaseClassExpression(clazz) !== null;
-    }
-    getBaseClassExpression(clazz) {
-        if (!(typescript_1.default.isClassDeclaration(clazz) || typescript_1.default.isClassExpression(clazz)) ||
-            clazz.heritageClauses === undefined) {
-            return null;
-        }
-        const extendsClause = clazz.heritageClauses.find((clause) => clause.token === typescript_1.default.SyntaxKind.ExtendsKeyword);
-        if (extendsClause === undefined) {
-            return null;
-        }
-        const extendsType = extendsClause.types[0];
-        if (extendsType === undefined) {
-            return null;
-        }
-        return extendsType.expression;
-    }
-    getGenericArityOfClass(clazz) {
-        if (!typescript_1.default.isClassDeclaration(clazz)) {
-            return null;
-        }
-        return clazz.typeParameters !== undefined ? clazz.typeParameters.length : 0;
-    }
-    getDirectImportOfIdentifier(id) {
-        const symbol = this.checker.getSymbolAtLocation(id);
-        if (symbol === undefined ||
-            symbol.declarations === undefined ||
-            symbol.declarations.length !== 1) {
-            return null;
-        }
-        const decl = symbol.declarations[0];
-        const importDecl = getContainingImportDeclaration(decl);
-        // Ignore declarations that are defined locally (not imported).
-        if (importDecl === null) {
-            return null;
-        }
-        // The module specifier is guaranteed to be a string literal, so this should always pass.
-        if (!typescript_1.default.isStringLiteral(importDecl.moduleSpecifier)) {
-            // Not allowed to happen in TypeScript ASTs.
-            return null;
-        }
-        return {
-            from: importDecl.moduleSpecifier.text,
-            name: getExportedName(decl, id),
-            node: importDecl,
-        };
-    }
-    /**
-     * Try to get the import info for this identifier as though it is a namespaced import.
-     *
-     * For example, if the identifier is the `Directive` part of a qualified type chain like:
-     *
-     * ```
-     * core.Directive
-     * ```
-     *
-     * then it might be that `core` is a namespace import such as:
-     *
-     * ```
-     * import * as core from 'tslib';
-     * ```
-     *
-     * @param id the TypeScript identifier to find the import info for.
-     * @returns The import info if this is a namespaced import or `null`.
-     */
-    getImportOfNamespacedIdentifier(id, namespaceIdentifier) {
-        if (namespaceIdentifier === null) {
-            return null;
-        }
-        const namespaceSymbol = this.checker.getSymbolAtLocation(namespaceIdentifier);
-        if (!namespaceSymbol || namespaceSymbol.declarations === undefined) {
-            return null;
-        }
-        const declaration = namespaceSymbol.declarations.length === 1
-            ? namespaceSymbol.declarations[0]
-            : null;
-        if (!declaration) {
-            return null;
-        }
-        const namespaceDeclaration = typescript_1.default.isNamespaceImport(declaration)
-            ? declaration
-            : null;
-        if (!namespaceDeclaration) {
-            return null;
-        }
-        const importDeclaration = namespaceDeclaration.parent.parent;
-        if (!typescript_1.default.isStringLiteral(importDeclaration.moduleSpecifier)) {
-            // Should not happen as this would be invalid TypesScript
-            return null;
-        }
-        return {
-            from: importDeclaration.moduleSpecifier.text,
-            name: id.text,
-            node: namespaceDeclaration.parent.parent,
-        };
-    }
-    _reflectDecorator(node) {
-        // Attempt to resolve the decorator expression into a reference to a concrete Identifier. The
-        // expression may contain a call to a function which returns the decorator function, in which
-        // case we want to return the arguments.
-        let decoratorExpr = node.expression;
-        let args = null;
-        // Check for call expressions.
-        if (typescript_1.default.isCallExpression(decoratorExpr)) {
-            args = Array.from(decoratorExpr.arguments);
-            decoratorExpr = decoratorExpr.expression;
-        }
-        // The final resolved decorator should be a `ts.Identifier` - if it's not, then something is
-        // wrong and the decorator can't be resolved statically.
-        if (!(0, host_1.isDecoratorIdentifier)(decoratorExpr)) {
-            return null;
-        }
-        const decoratorIdentifier = typescript_1.default.isIdentifier(decoratorExpr)
-            ? decoratorExpr
-            : decoratorExpr.name;
-        const importDecl = this.getImportOfIdentifier(decoratorIdentifier);
-        return {
-            name: decoratorIdentifier.text,
-            identifier: decoratorExpr,
-            import: importDecl,
-            node,
-            args,
-        };
-    }
-    _reflectMember(node) {
-        let kind = null;
-        let value = null;
-        let name = null;
-        let nameNode = null;
-        if (typescript_1.default.isPropertyDeclaration(node)) {
-            kind = host_1.ClassMemberKind.Property;
-            value = node.initializer || null;
-        }
-        else if (typescript_1.default.isGetAccessorDeclaration(node)) {
-            kind = host_1.ClassMemberKind.Getter;
-        }
-        else if (typescript_1.default.isSetAccessorDeclaration(node)) {
-            kind = host_1.ClassMemberKind.Setter;
-        }
-        else if (typescript_1.default.isMethodDeclaration(node)) {
-            kind = host_1.ClassMemberKind.Method;
-        }
-        else if (typescript_1.default.isConstructorDeclaration(node)) {
-            kind = host_1.ClassMemberKind.Constructor;
-        }
-        else {
-            return null;
-        }
-        if (typescript_1.default.isConstructorDeclaration(node)) {
-            name = 'constructor';
-        }
-        else if (typescript_1.default.isIdentifier(node.name)) {
-            name = node.name.text;
-            nameNode = node.name;
-        }
-        else if (typescript_1.default.isStringLiteral(node.name)) {
-            name = node.name.text;
-            nameNode = node.name;
-        }
-        else {
-            return null;
-        }
-        const decorators = this.getDecoratorsOfDeclaration(node);
-        const modifiers = typescript_1.default.getModifiers(node);
-        const isStatic = modifiers !== undefined &&
-            modifiers.some((mod) => mod.kind === typescript_1.default.SyntaxKind.StaticKeyword);
-        return {
-            node,
-            implementation: node,
-            kind,
-            type: node.type || null,
-            name,
-            nameNode,
-            decorators,
-            value,
-            isStatic,
-        };
-    }
-    _viaModule(declaration, originalId, importInfo) {
-        if (importInfo === null &&
-            originalId !== null &&
-            declaration.getSourceFile() !== originalId.getSourceFile()) {
-            return host_1.AmbientImport;
-        }
-        return importInfo !== null &&
-            importInfo.from !== null &&
-            !importInfo.from.startsWith('.')
-            ? importInfo.from
-            : null;
-    }
-}
-exports.TypeScriptReflectionHost = TypeScriptReflectionHost;
-function reflectObjectLiteral(node) {
-    const map = new Map();
-    node.properties.forEach((prop) => {
-        if (typescript_1.default.isPropertyAssignment(prop)) {
-            const name = propertyNameToString(prop.name);
-            if (name === null) {
-                return;
-            }
-            map.set(name, prop.initializer);
-        }
-        else if (typescript_1.default.isShorthandPropertyAssignment(prop)) {
-            map.set(prop.name.text, prop.name);
-        }
-        else {
-            return;
-        }
-    });
-    return map;
-}
-exports.reflectObjectLiteral = reflectObjectLiteral;
-function castDeclarationToClassOrDie(declaration) {
-    if (!typescript_1.default.isClassDeclaration(declaration)) {
-        throw new Error(`Reflecting on a ${typescript_1.default.SyntaxKind[declaration.kind]} instead of a ClassDeclaration.`);
-    }
-    return declaration;
-}
-function parameterName(name) {
-    if (typescript_1.default.isIdentifier(name)) {
-        return name.text;
-    }
-    else {
-        return null;
-    }
-}
-function propertyNameToString(node) {
-    if (typescript_1.default.isIdentifier(node) ||
-        typescript_1.default.isStringLiteral(node) ||
-        typescript_1.default.isNumericLiteral(node)) {
-        return node.text;
-    }
-    else {
-        return null;
-    }
-}
-/**
- * Compute the left most identifier in a qualified type chain. E.g. the `a` of `a.b.c.SomeType`.
- * @param qualifiedName The starting property access expression from which we want to compute
- * the left most identifier.
- * @returns the left most identifier in the chain or `null` if it is not an identifier.
- */
-function getQualifiedNameRoot(qualifiedName) {
-    while (typescript_1.default.isQualifiedName(qualifiedName.left)) {
-        qualifiedName = qualifiedName.left;
-    }
-    return typescript_1.default.isIdentifier(qualifiedName.left) ? qualifiedName.left : null;
-}
-/**
- * Compute the left most identifier in a property access chain. E.g. the `a` of `a.b.c.d`.
- * @param propertyAccess The starting property access expression from which we want to compute
- * the left most identifier.
- * @returns the left most identifier in the chain or `null` if it is not an identifier.
- */
-function getFarLeftIdentifier(propertyAccess) {
-    while (typescript_1.default.isPropertyAccessExpression(propertyAccess.expression)) {
-        propertyAccess = propertyAccess.expression;
-    }
-    return typescript_1.default.isIdentifier(propertyAccess.expression)
-        ? propertyAccess.expression
-        : null;
-}
-/**
- * Gets the closest ancestor `ImportDeclaration` to a node.
- */
-function getContainingImportDeclaration(node) {
-    let parent = node.parent;
-    while (parent && !typescript_1.default.isSourceFile(parent)) {
-        if (typescript_1.default.isImportDeclaration(parent)) {
-            return parent;
-        }
-        parent = parent.parent;
-    }
-    return null;
-}
-exports.getContainingImportDeclaration = getContainingImportDeclaration;
-/**
- * Compute the name by which the `decl` was exported, not imported.
- * If no such declaration can be found (e.g. it is a namespace import)
- * then fallback to the `originalId`.
- */
-function getExportedName(decl, originalId) {
-    return typescript_1.default.isImportSpecifier(decl)
-        ? (decl.propertyName !== undefined ? decl.propertyName : decl.name).text
-        : originalId.text;
-}
-const LocalExportedDeclarations = Symbol('LocalExportedDeclarations');

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

@@ -1,12 +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 ts from 'typescript';
-import { ClassDeclaration } from './host';
-export declare function isNamedClassDeclaration(node: ts.Node): node is ClassDeclaration<ts.ClassDeclaration>;
-export declare function isNamedFunctionDeclaration(node: ts.Node): node is ClassDeclaration<ts.FunctionDeclaration>;
-export declare function isNamedVariableDeclaration(node: ts.Node): node is ClassDeclaration<ts.VariableDeclaration>;

package/transform/compiler-cli/src/ngtsc/reflection/src/util.js

@@ -1,29 +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.isNamedVariableDeclaration = exports.isNamedFunctionDeclaration = exports.isNamedClassDeclaration = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-function isNamedClassDeclaration(node) {
-    return typescript_1.default.isClassDeclaration(node) && isIdentifier(node.name);
-}
-exports.isNamedClassDeclaration = isNamedClassDeclaration;
-function isNamedFunctionDeclaration(node) {
-    return typescript_1.default.isFunctionDeclaration(node) && isIdentifier(node.name);
-}
-exports.isNamedFunctionDeclaration = isNamedFunctionDeclaration;
-function isNamedVariableDeclaration(node) {
-    return typescript_1.default.isVariableDeclaration(node) && isIdentifier(node.name);
-}
-exports.isNamedVariableDeclaration = isNamedVariableDeclaration;
-function isIdentifier(node) {
-    return node !== undefined && typescript_1.default.isIdentifier(node);
-}

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

@@ -1,2 +0,0 @@
-export * from './src/api';
-export * from './src/utils';

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

@@ -1,18 +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/api"), exports);
-__exportStar(require("./src/utils"), exports);

package/transform/compiler-cli/src/ngtsc/transform/src/api.d.ts

@@ -1,115 +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, Statement, Type } from 'static-injector/transform/compiler';
-import ts from 'typescript';
-import { ClassDeclaration, Decorator } from '../../reflection';
-/**
- * Specifies the compilation mode that is used for the compilation.
- */
-export declare enum CompilationMode {
-    /**
-     * Generates fully AOT compiled code using Ivy instructions.
-     */
-    FULL = 0,
-    /**
-     * Generates code using a stable, but intermediate format suitable to be published to NPM.
-     */
-    PARTIAL = 1,
-    /**
-     * Generates code based on each individual source file without using its
-     * dependencies (suitable for local dev edit/refresh workflow).
-     */
-    LOCAL = 2
-}
-/**
- * Provides the interface between a decorator compiler from @angular/compiler and the Typescript
- * compiler/transform.
- *
- * The decorator compilers in @angular/compiler do not depend on Typescript. The handler is
- * responsible for extracting the information required to perform compilation from the decorators
- * and Typescript source, invoking the decorator compiler, and returning the result.
- *
- * @param `D` The type of decorator metadata produced by `detect`.
- * @param `A` The type of analysis metadata produced by `analyze`.
- * @param `R` The type of resolution metadata produced by `resolve`.
- */
-export interface DecoratorHandler<D, A, R> {
-    /**
-     * Scan a set of reflected decorators and determine if this handler is responsible for compilation
-     * of one of them.
-     */
-    detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<D> | undefined;
-    /**
-     * Asynchronously perform pre-analysis on the decorator/class combination.
-     *
-     * `preanalyze` is optional and is not guaranteed to be called through all compilation flows. It
-     * will only be called if asynchronicity is supported in the CompilerHost.
-     */
-    preanalyze?(node: ClassDeclaration, metadata: Readonly<D>): Promise<void> | undefined;
-    /**
-     * Perform analysis on the decorator/class combination, extracting information from the class
-     * required for compilation.
-     *
-     * Returns analyzed metadata if successful, or an array of diagnostic messages if the analysis
-     * fails or the decorator isn't valid.
-     *
-     * Analysis should always be a "pure" operation, with no side effects. This is because the
-     * detect/analysis steps might be skipped for files which have not changed during incremental
-     * builds. Any side effects required for compilation (e.g. registration of metadata) should happen
-     * in the `register` phase, which is guaranteed to run even for incremental builds.
-     */
-    analyze(node: ClassDeclaration, metadata: Readonly<D>): AnalysisOutput<A>;
-    /**
-     * Generate a description of the field which should be added to the class, including any
-     * initialization code to be generated.
-     *
-     * If the compilation mode is configured as other than full but an implementation of the
-     * corresponding method is not provided, then this method is called as a fallback.
-     */
-    compileFull(node: ClassDeclaration, analysis: Readonly<A>): CompileResult | CompileResult[];
-}
-/**
- * The output of detecting a trait for a declaration as the result of the first phase of the
- * compilation pipeline.
- */
-export interface DetectResult<M> {
-    /**
-     * The node that triggered the match, which is typically a decorator.
-     */
-    trigger: ts.Node | null;
-    /**
-     * Refers to the decorator that was recognized for this detection, if any. This can be a concrete
-     * decorator that is actually present in a file, or a synthetic decorator as inserted
-     * programmatically.
-     */
-    decorator: Decorator | null;
-    /**
-     * An arbitrary object to carry over from the detection phase into the analysis phase.
-     */
-    metadata: Readonly<M>;
-}
-/**
- * The output of an analysis operation, consisting of possibly an arbitrary analysis object (used as
- * the input to code generation) and potentially diagnostics if there were errors uncovered during
- * analysis.
- */
-export interface AnalysisOutput<A> {
-    analysis?: Readonly<A>;
-    diagnostics?: ts.Diagnostic[];
-}
-/**
- * A description of the static field to add to a class, including an initialization expression
- * and a type for the .d.ts file.
- */
-export interface CompileResult {
-    name: string;
-    initializer: Expression | null;
-    statements: Statement[];
-    type: Type;
-    deferrableImports: Set<ts.ImportDeclaration> | null;
-}

package/transform/compiler-cli/src/ngtsc/transform/src/api.js

@@ -1,29 +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.CompilationMode = void 0;
-/**
- * Specifies the compilation mode that is used for the compilation.
- */
-var CompilationMode;
-(function (CompilationMode) {
-    /**
-     * Generates fully AOT compiled code using Ivy instructions.
-     */
-    CompilationMode[CompilationMode["FULL"] = 0] = "FULL";
-    /**
-     * Generates code using a stable, but intermediate format suitable to be published to NPM.
-     */
-    CompilationMode[CompilationMode["PARTIAL"] = 1] = "PARTIAL";
-    /**
-     * Generates code based on each individual source file without using its
-     * dependencies (suitable for local dev edit/refresh workflow).
-     */
-    CompilationMode[CompilationMode["LOCAL"] = 2] = "LOCAL";
-})(CompilationMode || (exports.CompilationMode = CompilationMode = {}));

package/transform/compiler-cli/src/ngtsc/transform/src/utils.d.ts

@@ -1,15 +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 ts from 'typescript';
-import { ImportManager } from '../../translator';
-/**
- * Adds extra imports in the import manage for this source file, after the existing imports
- * and before the module body.
- * Can optionally add extra statements (e.g. new constants) before the body as well.
- */
-export declare function addImports(factory: ts.NodeFactory | undefined, importManager: ImportManager, sf: ts.SourceFile, extraStatements?: ts.Statement[]): ts.SourceFile;