static-injector 1.0.8

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @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 ts from "typescript";
+import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from "./api/ast_factory";
+/**
+ * A TypeScript flavoured implementation of the AstFactory.
+ */
+export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression> {
+    private annotateForClosureCompiler;
+    private externalSourceFiles;
+    constructor(annotateForClosureCompiler: boolean);
+    attachComments: typeof attachComments;
+    createArrayLiteral: (elements?: readonly ts.Expression[], multiLine?: boolean) => ts.ArrayLiteralExpression;
+    createAssignment(target: ts.Expression, value: ts.Expression): ts.Expression;
+    createBinaryExpression(leftOperand: ts.Expression, operator: BinaryOperator, rightOperand: ts.Expression): ts.Expression;
+    createBlock(body: ts.Statement[]): ts.Statement;
+    createCallExpression(callee: ts.Expression, args: ts.Expression[], pure: boolean): ts.Expression;
+    createConditional: {
+        (condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.ConditionalExpression;
+        (condition: ts.Expression, questionToken: ts.QuestionToken, whenTrue: ts.Expression, colonToken: ts.ColonToken, whenFalse: ts.Expression): ts.ConditionalExpression;
+    };
+    createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
+    createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
+    createFunctionDeclaration(functionName: string, parameters: string[], body: ts.Statement): ts.Statement;
+    createFunctionExpression(functionName: string | null, parameters: string[], body: ts.Statement): ts.Expression;
+    createIdentifier: (text: string) => ts.Identifier;
+    createIfStatement(condition: ts.Expression, thenStatement: ts.Statement, elseStatement: ts.Statement | null): ts.Statement;
+    createLiteral(value: string | number | boolean | null | undefined): ts.Expression;
+    createNewExpression(expression: ts.Expression, args: ts.Expression[]): ts.Expression;
+    createObjectLiteral(properties: ObjectLiteralProperty<ts.Expression>[]): ts.Expression;
+    createParenthesizedExpression: (expression: ts.Expression) => ts.ParenthesizedExpression;
+    createPropertyAccess: (expression: ts.Expression, name: string | ts.MemberName) => ts.PropertyAccessExpression;
+    createReturnStatement(expression: ts.Expression | null): ts.Statement;
+    createTaggedTemplate(tag: ts.Expression, template: TemplateLiteral<ts.Expression>): ts.Expression;
+    createThrowStatement: (expression: ts.Expression) => ts.ThrowStatement;
+    createTypeOfExpression: (expression: ts.Expression) => ts.TypeOfExpression;
+    createUnaryExpression(operator: UnaryOperator, operand: ts.Expression): ts.Expression;
+    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, type: VariableDeclarationType): ts.Statement;
+    setSourceMapRange<T extends ts.Node>(node: T, sourceMapRange: SourceMapRange | null): T;
+}
+export declare function createTemplateMiddle(cooked: string, raw: string): ts.TemplateMiddle;
+export declare function createTemplateTail(cooked: string, raw: string): ts.TemplateTail;
+/**
+ * Attach the given `leadingComments` to the `statement` node.
+ *
+ * @param statement The statement that will have comments attached.
+ * @param leadingComments The comments to attach to the statement.
+ */
+export declare function attachComments(statement: ts.Statement, leadingComments: LeadingComment[]): void;

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_ast_factory.js

@@ -0,0 +1,245 @@
+"use strict";
+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.attachComments = exports.createTemplateTail = exports.createTemplateMiddle = exports.TypeScriptAstFactory = void 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
+ */
+const ts = __importStar(require("typescript"));
+/**
+ * Different optimizers use different annotations on a function or method call to indicate its pure
+ * status.
+ */
+var PureAnnotation;
+(function (PureAnnotation) {
+    /**
+     * Closure's annotation for purity is `@pureOrBreakMyCode`, but this needs to be in a semantic
+     * (jsdoc) enabled comment. Thus, the actual comment text for Closure must include the `*` that
+     * turns a `/*` comment into a `/**` comment, as well as surrounding whitespace.
+     */
+    PureAnnotation["CLOSURE"] = "* @pureOrBreakMyCode ";
+    PureAnnotation["TERSER"] = "@__PURE__";
+})(PureAnnotation || (PureAnnotation = {}));
+const UNARY_OPERATORS = {
+    "+": ts.SyntaxKind.PlusToken,
+    "-": ts.SyntaxKind.MinusToken,
+    "!": ts.SyntaxKind.ExclamationToken,
+};
+const BINARY_OPERATORS = {
+    "&&": ts.SyntaxKind.AmpersandAmpersandToken,
+    ">": ts.SyntaxKind.GreaterThanToken,
+    ">=": ts.SyntaxKind.GreaterThanEqualsToken,
+    "&": ts.SyntaxKind.AmpersandToken,
+    "/": ts.SyntaxKind.SlashToken,
+    "==": ts.SyntaxKind.EqualsEqualsToken,
+    "===": ts.SyntaxKind.EqualsEqualsEqualsToken,
+    "<": ts.SyntaxKind.LessThanToken,
+    "<=": ts.SyntaxKind.LessThanEqualsToken,
+    "-": ts.SyntaxKind.MinusToken,
+    "%": ts.SyntaxKind.PercentToken,
+    "*": ts.SyntaxKind.AsteriskToken,
+    "!=": ts.SyntaxKind.ExclamationEqualsToken,
+    "!==": ts.SyntaxKind.ExclamationEqualsEqualsToken,
+    "||": ts.SyntaxKind.BarBarToken,
+    "+": ts.SyntaxKind.PlusToken,
+    "??": ts.SyntaxKind.QuestionQuestionToken,
+};
+const VAR_TYPES = {
+    const: ts.NodeFlags.Const,
+    let: ts.NodeFlags.Let,
+    var: ts.NodeFlags.None,
+};
+/**
+ * A TypeScript flavoured implementation of the AstFactory.
+ */
+class TypeScriptAstFactory {
+    constructor(annotateForClosureCompiler) {
+        this.annotateForClosureCompiler = annotateForClosureCompiler;
+        this.externalSourceFiles = new Map();
+        this.attachComments = attachComments;
+        this.createArrayLiteral = ts.createArrayLiteral;
+        this.createConditional = ts.createConditional;
+        this.createElementAccess = ts.createElementAccess;
+        this.createExpressionStatement = ts.createExpressionStatement;
+        this.createIdentifier = ts.createIdentifier;
+        this.createParenthesizedExpression = ts.createParen;
+        this.createPropertyAccess = ts.createPropertyAccess;
+        this.createThrowStatement = ts.createThrow;
+        this.createTypeOfExpression = ts.createTypeOf;
+    }
+    createAssignment(target, value) {
+        return ts.createBinary(target, ts.SyntaxKind.EqualsToken, value);
+    }
+    createBinaryExpression(leftOperand, operator, rightOperand) {
+        return ts.createBinary(leftOperand, BINARY_OPERATORS[operator], rightOperand);
+    }
+    createBlock(body) {
+        return ts.createBlock(body);
+    }
+    createCallExpression(callee, args, pure) {
+        const call = ts.createCall(callee, undefined, args);
+        if (pure) {
+            ts.addSyntheticLeadingComment(call, ts.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler
+                ? PureAnnotation.CLOSURE
+                : PureAnnotation.TERSER, 
+            /* trailing newline */ false);
+        }
+        return call;
+    }
+    createFunctionDeclaration(functionName, parameters, body) {
+        if (!ts.isBlock(body)) {
+            throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
+        }
+        return ts.createFunctionDeclaration(undefined, undefined, undefined, functionName, undefined, parameters.map((param) => ts.createParameter(undefined, undefined, undefined, param)), undefined, body);
+    }
+    createFunctionExpression(functionName, parameters, body) {
+        if (!ts.isBlock(body)) {
+            throw new Error(`Invalid syntax, expected a block, but got ${ts.SyntaxKind[body.kind]}.`);
+        }
+        return ts.createFunctionExpression(undefined, undefined, functionName !== null && functionName !== void 0 ? functionName : undefined, undefined, parameters.map((param) => ts.createParameter(undefined, undefined, undefined, param)), undefined, body);
+    }
+    createIfStatement(condition, thenStatement, elseStatement) {
+        return ts.createIf(condition, thenStatement, elseStatement !== null && elseStatement !== void 0 ? elseStatement : undefined);
+    }
+    createLiteral(value) {
+        if (value === undefined) {
+            return ts.createIdentifier("undefined");
+        }
+        else if (value === null) {
+            return ts.createNull();
+        }
+        else {
+            return ts.createLiteral(value);
+        }
+    }
+    createNewExpression(expression, args) {
+        return ts.createNew(expression, undefined, args);
+    }
+    createObjectLiteral(properties) {
+        return ts.createObjectLiteral(properties.map((prop) => ts.createPropertyAssignment(prop.quoted
+            ? ts.createLiteral(prop.propertyName)
+            : ts.createIdentifier(prop.propertyName), prop.value)));
+    }
+    createReturnStatement(expression) {
+        return ts.createReturn(expression !== null && expression !== void 0 ? expression : undefined);
+    }
+    createTaggedTemplate(tag, template) {
+        let templateLiteral;
+        const length = template.elements.length;
+        const head = template.elements[0];
+        if (length === 1) {
+            templateLiteral = ts.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+        }
+        else {
+            const spans = [];
+            // Create the middle parts
+            for (let i = 1; i < length - 1; i++) {
+                const { cooked, raw, range } = template.elements[i];
+                const middle = createTemplateMiddle(cooked, raw);
+                if (range !== null) {
+                    this.setSourceMapRange(middle, range);
+                }
+                spans.push(ts.createTemplateSpan(template.expressions[i - 1], middle));
+            }
+            // Create the tail part
+            const resolvedExpression = template.expressions[length - 2];
+            const templatePart = template.elements[length - 1];
+            const templateTail = createTemplateTail(templatePart.cooked, templatePart.raw);
+            if (templatePart.range !== null) {
+                this.setSourceMapRange(templateTail, templatePart.range);
+            }
+            spans.push(ts.createTemplateSpan(resolvedExpression, templateTail));
+            // Put it all together
+            templateLiteral = ts.createTemplateExpression(ts.createTemplateHead(head.cooked, head.raw), spans);
+        }
+        if (head.range !== null) {
+            this.setSourceMapRange(templateLiteral, head.range);
+        }
+        return ts.createTaggedTemplate(tag, templateLiteral);
+    }
+    createUnaryExpression(operator, operand) {
+        return ts.createPrefix(UNARY_OPERATORS[operator], operand);
+    }
+    createVariableDeclaration(variableName, initializer, type) {
+        return ts.createVariableStatement(undefined, ts.createVariableDeclarationList([
+            ts.createVariableDeclaration(variableName, undefined, initializer !== null && initializer !== void 0 ? initializer : undefined),
+        ], VAR_TYPES[type]));
+    }
+    setSourceMapRange(node, sourceMapRange) {
+        if (sourceMapRange === null) {
+            return node;
+        }
+        const url = sourceMapRange.url;
+        if (!this.externalSourceFiles.has(url)) {
+            this.externalSourceFiles.set(url, ts.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+        }
+        const source = this.externalSourceFiles.get(url);
+        ts.setSourceMapRange(node, {
+            pos: sourceMapRange.start.offset,
+            end: sourceMapRange.end.offset,
+            source,
+        });
+        return node;
+    }
+}
+exports.TypeScriptAstFactory = TypeScriptAstFactory;
+// HACK: Use this in place of `ts.createTemplateMiddle()`.
+// Revert once https://github.com/microsoft/TypeScript/issues/35374 is fixed.
+function createTemplateMiddle(cooked, raw) {
+    const node = ts.createTemplateHead(cooked, raw);
+    node.kind = ts.SyntaxKind.TemplateMiddle;
+    return node;
+}
+exports.createTemplateMiddle = createTemplateMiddle;
+// HACK: Use this in place of `ts.createTemplateTail()`.
+// Revert once https://github.com/microsoft/TypeScript/issues/35374 is fixed.
+function createTemplateTail(cooked, raw) {
+    const node = ts.createTemplateHead(cooked, raw);
+    node.kind = ts.SyntaxKind.TemplateTail;
+    return node;
+}
+exports.createTemplateTail = createTemplateTail;
+/**
+ * Attach the given `leadingComments` to the `statement` node.
+ *
+ * @param statement The statement that will have comments attached.
+ * @param leadingComments The comments to attach to the statement.
+ */
+function attachComments(statement, leadingComments) {
+    for (const comment of leadingComments) {
+        const commentKind = comment.multiline
+            ? ts.SyntaxKind.MultiLineCommentTrivia
+            : ts.SyntaxKind.SingleLineCommentTrivia;
+        if (comment.multiline) {
+            ts.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+        }
+        else {
+            for (const line of comment.toString().split("\n")) {
+                ts.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+            }
+        }
+    }
+}
+exports.attachComments = attachComments;

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_translator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 "../../../../../compiler";
+import * as ts from "typescript";
+import { ImportGenerator } from "./api/import_generator";
+import { TranslatorOptions } from "./translator";
+export declare function translateExpression(expression: o.Expression, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Expression;
+export declare function translateStatement(statement: o.Statement, imports: ImportGenerator<ts.Expression>, options?: TranslatorOptions<ts.Expression>): ts.Statement;

package/transform/compiler-cli/src/ngtsc/translator/src/typescript_translator.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.translateStatement = exports.translateExpression = void 0;
+const context_1 = require("./context");
+const translator_1 = require("./translator");
+const typescript_ast_factory_1 = require("./typescript_ast_factory");
+function translateExpression(expression, imports, options = {}) {
+    return expression.visitExpression(new translator_1.ExpressionTranslatorVisitor(new typescript_ast_factory_1.TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new context_1.Context(false));
+}
+exports.translateExpression = translateExpression;
+function translateStatement(statement, imports, options = {}) {
+    return statement.visitStatement(new translator_1.ExpressionTranslatorVisitor(new typescript_ast_factory_1.TypeScriptAstFactory(options.annotateForClosureCompiler === true), imports, options), new context_1.Context(true));
+}
+exports.translateStatement = translateStatement;

package/transform/compiler-cli/src/ngtsc/util/src/typescript.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 * as ts from "typescript";
+export declare function identifierOfNode(decl: ts.Node & {
+    name?: ts.Node;
+}): ts.Identifier | null;

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

@@ -0,0 +1,39 @@
+"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.identifierOfNode = void 0;
+const ts = __importStar(require("typescript"));
+function identifierOfNode(decl) {
+    if (decl.name !== undefined && ts.isIdentifier(decl.name)) {
+        return decl.name;
+    }
+    else {
+        return null;
+    }
+}
+exports.identifierOfNode = identifierOfNode;

package/transform/index.d.ts

@@ -0,0 +1 @@
+export * from "./injectable-transform";

package/transform/index.js

@@ -0,0 +1,13 @@
+"use strict";
+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 __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("./injectable-transform"), exports);

package/transform/injectable-transform.d.ts

@@ -0,0 +1,41 @@
+import ts from 'typescript';
+import { InjectableDecoratorHandler } from './compiler-cli/src/ngtsc/annotations/src/injectable';
+import { TypeScriptReflectionHost } from './compiler-cli/src/ngtsc/reflection';
+export interface InjectableTransformerFactoryOptions {
+    strictCtorDeps?: boolean;
+}
+export declare function createTransformer(program: ts.Program, options?: InjectableTransformerFactoryOptions): (context: ts.TransformationContext) => (sf: ts.SourceFile) => any;
+export declare class InjectableTransformerFactory {
+    private program;
+    private options;
+    typeChecker: ts.TypeChecker;
+    reflectionHost: TypeScriptReflectionHost;
+    handler: InjectableDecoratorHandler;
+    constructor(program: ts.Program, options?: InjectableTransformerFactoryOptions);
+    getTransform(): (context: ts.TransformationContext) => (sf: ts.SourceFile) => any;
+    private visit;
+    private transform;
+    private preAnalysis;
+    private translate;
+    /**
+     * Remove Angular decorators from a `ts.Node` in a shallow manner.
+     *
+     * This will remove decorators from class elements (getters, setters, properties, methods) as well
+     * as parameters of constructors.
+     */
+    private _stripAngularDecorators;
+    /**
+     * Return all decorators on a `Declaration` which are from static-injector, or an empty set if none
+     * are.
+     */
+    private _angularCoreDecorators;
+    /**
+     * Given a `ts.Node`, filter the decorators array and return a version containing only non-Angular
+     * decorators.
+     *
+     * If all decorators are removed (or none existed in the first place), this method returns
+     * `undefined`.
+     */
+    private _nonCoreDecoratorsOnly;
+    private updateStatements;
+}