static-injector 1.0.8

package/transform/injectable-transform.js

@@ -0,0 +1,195 @@
+"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.InjectableTransformerFactory = exports.createTransformer = void 0;
+const typescript_1 = __importStar(require("typescript"));
+const injectable_1 = require("./compiler-cli/src/ngtsc/annotations/src/injectable");
+const imports_1 = require("./compiler-cli/src/ngtsc/imports");
+const reflection_1 = require("./compiler-cli/src/ngtsc/reflection");
+const transform_1 = require("./compiler-cli/src/ngtsc/transform");
+const translator_1 = require("./compiler-cli/src/ngtsc/translator");
+const node_Iteration_1 = require("./node-Iteration");
+const NO_DECORATORS = new Set();
+function createTransformer(program, options) {
+    let factory = new InjectableTransformerFactory(program, options);
+    return factory.getTransform();
+}
+exports.createTransformer = createTransformer;
+class InjectableTransformerFactory {
+    constructor(program, options = {}) {
+        this.program = program;
+        this.options = options;
+        this.typeChecker = this.program.getTypeChecker();
+        this.reflectionHost = new reflection_1.TypeScriptReflectionHost(this.typeChecker);
+        this.handler = new injectable_1.InjectableDecoratorHandler(this.reflectionHost, false, this.options.strictCtorDeps);
+    }
+    getTransform() {
+        return (context) => this.transform(context);
+    }
+    visit(node, context, map) {
+        return typescript_1.default.visitEachChild(node, (node) => {
+            let result = map.get(node);
+            if (result) {
+                let decoratorList = node.decorators.filter((item) => item !== result.decorator);
+                return typescript_1.factory.updateClassDeclaration(node, decoratorList.length ? decoratorList : undefined, node.modifiers, node.name, node.typeParameters, node.heritageClauses, [
+                    ...node.members.map((node) => this._stripAngularDecorators(node)),
+                    ...result.members,
+                ]);
+            }
+            return this.visit(node, context, map);
+        }, context);
+    }
+    transform(context) {
+        return (sf) => {
+            let map = this.preAnalysis(sf);
+            sf = this.updateStatements(sf, map.importManager);
+            return this.visit(sf, context, map.classMetadataMap);
+        };
+    }
+    preAnalysis(sf) {
+        let classMetadataMap = new Map();
+        let write = new imports_1.NoopImportRewriter();
+        let importManager = new translator_1.ImportManager(write);
+        node_Iteration_1.nodeIteration(sf, (node) => {
+            if (typescript_1.default.isClassDeclaration(node) &&
+                node.decorators &&
+                this.reflectionHost.isClass(node)) {
+                const decorators = this.reflectionHost.getDecoratorsOfDeclaration(node);
+                let result = this.handler.detect(node, decorators);
+                let analysisOutput = this.handler.analyze(node, result.metadata);
+                let compileResult = this.handler.compileFull(node, analysisOutput.analysis);
+                let resultNode = this.translate(compileResult, importManager);
+                classMetadataMap.set(node, Object.assign(Object.assign({}, resultNode), { decorator: result.trigger }));
+            }
+        });
+        // this.sourceFileMetadataMap.set(sf, {
+        //   classMetadataMap,
+        //   importManager: importManager,
+        // });
+        return { classMetadataMap, importManager };
+    }
+    translate(compileResult, importManager) {
+        // There is at least one field to add.
+        const statements = [];
+        const members = [];
+        for (const field of compileResult) {
+            // Translate the initializer for the field into TS nodes.
+            const exprNode = translator_1.translateExpression(field.initializer, importManager);
+            // Create a static property declaration for the new field.
+            const property = typescript_1.default.createProperty(undefined, [typescript_1.default.createToken(typescript_1.default.SyntaxKind.StaticKeyword)], field.name, undefined, undefined, exprNode);
+            if (false) {
+                // Closure compiler transforms the form `Service.ɵprov = X` into `Service$ɵprov = X`. To
+                // prevent this transformation, such assignments need to be annotated with @nocollapse.
+                // Note that tsickle is typically responsible for adding such annotations, however it
+                // doesn't yet handle synthetic fields added during other transformations.
+                typescript_1.default.addSyntheticLeadingComment(property, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, '* @nocollapse ', 
+                /* hasTrailingNewLine */ false);
+            }
+            field.statements
+                .map((stmt) => translator_1.translateStatement(stmt, importManager))
+                .forEach((stmt) => statements.push(stmt));
+            members.push(property);
+        }
+        return { statements, members };
+    }
+    /**
+     * 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.
+     */
+    _stripAngularDecorators(node) {
+        if (typescript_1.default.isParameter(node)) {
+            // Strip decorators from parameters (probably of the constructor).
+            node = typescript_1.default.updateParameter(node, this._nonCoreDecoratorsOnly(node), node.modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+        }
+        else if (typescript_1.default.isConstructorDeclaration(node)) {
+            // For constructors, strip decorators of the parameters.
+            const parameters = node.parameters.map((param) => this._stripAngularDecorators(param));
+            node = typescript_1.default.updateConstructor(node, node.decorators, node.modifiers, parameters, node.body);
+        }
+        return node;
+    }
+    /**
+     * Return all decorators on a `Declaration` which are from static-injector, or an empty set if none
+     * are.
+     */
+    _angularCoreDecorators(decl) {
+        const decorators = this.reflectionHost.getDecoratorsOfDeclaration(decl);
+        if (decorators === null) {
+            return NO_DECORATORS;
+        }
+        const coreDecorators = decorators
+            .filter((dec) => isFromAngularCore(dec))
+            .map((dec) => dec.node);
+        if (coreDecorators.length > 0) {
+            return new Set(coreDecorators);
+        }
+        else {
+            return NO_DECORATORS;
+        }
+    }
+    /**
+     * 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`.
+     */
+    _nonCoreDecoratorsOnly(node) {
+        // Shortcut if the node has no decorators.
+        if (node.decorators === undefined) {
+            return undefined;
+        }
+        // Build a Set of the decorators on this node from static-injector.
+        const coreDecorators = this._angularCoreDecorators(node);
+        if (coreDecorators.size === node.decorators.length) {
+            // If all decorators are to be removed, return `undefined`.
+            return undefined;
+        }
+        else if (coreDecorators.size === 0) {
+            // If no decorators need to be removed, return the original decorators array.
+            return node.decorators;
+        }
+        // Filter out the core decorators.
+        const filtered = node.decorators.filter((dec) => !coreDecorators.has(dec));
+        // If no decorators survive, return `undefined`. This can only happen if a core decorator is
+        // repeated on the node.
+        if (filtered.length === 0) {
+            return undefined;
+        }
+        // Create a new `NodeArray` with the filtered decorators that sourcemaps back to the original.
+        const array = typescript_1.default.createNodeArray(filtered);
+        array.pos = node.decorators.pos;
+        array.end = node.decorators.end;
+        return array;
+    }
+    updateStatements(node, importManager) {
+        return transform_1.addImports(importManager, node);
+    }
+}
+exports.InjectableTransformerFactory = InjectableTransformerFactory;
+/**
+ * todo 引入
+ */
+function isFromAngularCore(decorator) {
+    return (decorator.import !== null && decorator.import.from === 'static-injector');
+}

package/transform/node-Iteration.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function nodeIteration(node: ts.Node, fn: (node: ts.Node) => any): void;

package/transform/node-Iteration.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeIteration = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+function nodeIteration(node, fn) {
+    fn(node);
+    typescript_1.default.forEachChild(node, (node) => nodeIteration(node, fn));
+}
+exports.nodeIteration = nodeIteration;