static-injector 1.0.8

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

@@ -0,0 +1,239 @@
+"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.isExpressionFactoryMetadata = exports.isDelegatedFactoryMetadata = exports.createFactoryType = exports.compileFactoryFunction = exports.FactoryTarget = exports.R3FactoryDelegateType = void 0;
+const outputAst = __importStar(require("../output/output_ast"));
+const r3_identifiers_1 = require("../render3/r3_identifiers");
+const util_1 = require("./util");
+var R3FactoryDelegateType;
+(function (R3FactoryDelegateType) {
+    R3FactoryDelegateType[R3FactoryDelegateType["Class"] = 0] = "Class";
+    R3FactoryDelegateType[R3FactoryDelegateType["Function"] = 1] = "Function";
+})(R3FactoryDelegateType = exports.R3FactoryDelegateType || (exports.R3FactoryDelegateType = {}));
+var FactoryTarget;
+(function (FactoryTarget) {
+    FactoryTarget[FactoryTarget["Directive"] = 0] = "Directive";
+    FactoryTarget[FactoryTarget["Component"] = 1] = "Component";
+    FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable";
+    FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
+    FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
+})(FactoryTarget = exports.FactoryTarget || (exports.FactoryTarget = {}));
+/**
+ * Construct a factory function expression for the given `R3FactoryMetadata`.
+ */
+function compileFactoryFunction(meta) {
+    const t = outputAst.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
+    // parameter provided by the user (t) if specified, or the current type if not. If there is a
+    // 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)
+        : 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));
+        }
+    }
+    else {
+        // There is no constructor, use the base class' factory to construct typeForCtor.
+        baseFactoryVar = outputAst.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 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()]));
+        return r;
+    }
+    if (isDelegatedFactoryMetadata(meta)) {
+        // This type is created with a delegated factory. If a type parameter is not specified, call
+        // the factory instead.
+        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);
+        retExpr = makeConditionalFactory(factoryExpr);
+    }
+    else if (isExpressionFactoryMetadata(meta)) {
+        // TODO(alxhub): decide whether to lower the value here or in the caller
+        retExpr = makeConditionalFactory(meta.expression);
+    }
+    else {
+        retExpr = ctorExpr;
+    }
+    if (retExpr === null) {
+        // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
+        body.push(outputAst.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
+            .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])));
+    }
+    else {
+        // This is straightforward factory, just return it.
+        body.push(new outputAst.ReturnStatement(retExpr));
+    }
+    let factoryFn = outputAst.fn([new outputAst.FnParam('t', outputAst.DYNAMIC_TYPE)], body, outputAst.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
+            .fn([], [
+            new outputAst.DeclareVarStmt(baseFactoryVar.name),
+            new outputAst.ReturnStatement(factoryFn),
+        ])
+            .callFn([], /* sourceSpan */ undefined, /* pure */ true);
+    }
+    return {
+        expression: factoryFn,
+        statements: [],
+        type: createFactoryType(meta),
+    };
+}
+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, [
+        util_1.typeWithParameters(meta.type.type, meta.typeArgumentCount),
+        ctorDepsType,
+    ]));
+}
+exports.createFactoryType = createFactoryType;
+function injectDependencies(deps, target) {
+    return deps.map((dep, index) => compileInjectDependency(dep, target, index));
+}
+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)]);
+    }
+    else if (dep.attributeNameType === null) {
+        // Build up the injection flags according to the metadata.
+        const flags = 0 /* Default */ |
+            (dep.self ? 2 /* Self */ : 0) |
+            (dep.skipSelf ? 4 /* SkipSelf */ : 0) |
+            (dep.optional ? 8 /* Optional */ : 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 /* Default */ || dep.optional
+            ? outputAst.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);
+    }
+}
+function createCtorDepsType(deps) {
+    let hasTypes = false;
+    const attributeTypes = deps.map((dep) => {
+        const type = createCtorDepType(dep);
+        if (type !== null) {
+            hasTypes = true;
+            return type;
+        }
+        else {
+            return outputAst.literal(null);
+        }
+    });
+    if (hasTypes) {
+        return outputAst.expressionType(outputAst.literalArr(attributeTypes));
+    }
+    else {
+        return outputAst.NONE_TYPE;
+    }
+}
+function createCtorDepType(dep) {
+    const entries = [];
+    if (dep.optional) {
+        entries.push({
+            key: 'optional',
+            value: outputAst.literal(true),
+            quoted: false,
+        });
+    }
+    if (dep.self) {
+        entries.push({
+            key: 'self',
+            value: outputAst.literal(true),
+            quoted: false,
+        });
+    }
+    if (dep.skipSelf) {
+        entries.push({
+            key: 'skipSelf',
+            value: outputAst.literal(true),
+            quoted: false,
+        });
+    }
+    return entries.length > 0 ? outputAst.literalMap(entries) : null;
+}
+function isDelegatedFactoryMetadata(meta) {
+    return meta.delegateType !== undefined;
+}
+exports.isDelegatedFactoryMetadata = isDelegatedFactoryMetadata;
+function isExpressionFactoryMetadata(meta) {
+    return meta.expression !== undefined;
+}
+exports.isExpressionFactoryMetadata = isExpressionFactoryMetadata;
+function getInjectFn(target) {
+    switch (target) {
+        case FactoryTarget.Component:
+        case FactoryTarget.Directive:
+        case FactoryTarget.Pipe:
+            return r3_identifiers_1.Identifiers.directiveInject;
+        case FactoryTarget.NgModule:
+        case FactoryTarget.Injectable:
+        default:
+            return r3_identifiers_1.Identifiers.inject;
+    }
+}

package/transform/compiler/src/render3/r3_identifiers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 '../output/output_ast';
+export declare class Identifiers {
+    static inject: o.ExternalReference;
+    static directiveInject: o.ExternalReference;
+    static invalidFactory: o.ExternalReference;
+    static invalidFactoryDep: o.ExternalReference;
+    static forwardRef: o.ExternalReference;
+    static resolveForwardRef: o.ExternalReference;
+    static ɵɵdefineInjectable: o.ExternalReference;
+    static InjectableDeclaration: o.ExternalReference;
+    static FactoryDeclaration: o.ExternalReference;
+    static getInheritedFactory: o.ExternalReference;
+}

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

@@ -0,0 +1,51 @@
+"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.Identifiers = void 0;
+const CORE = 'static-injector';
+class Identifiers {
+}
+exports.Identifiers = Identifiers;
+Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE };
+Identifiers.directiveInject = {
+    name: 'ɵɵdirectiveInject',
+    moduleName: CORE,
+};
+Identifiers.invalidFactory = {
+    name: 'ɵɵinvalidFactory',
+    moduleName: CORE,
+};
+Identifiers.invalidFactoryDep = {
+    name: 'ɵɵinvalidFactoryDep',
+    moduleName: CORE,
+};
+Identifiers.forwardRef = {
+    name: 'forwardRef',
+    moduleName: CORE,
+};
+Identifiers.resolveForwardRef = {
+    name: 'resolveForwardRef',
+    moduleName: CORE,
+};
+Identifiers.ɵɵdefineInjectable = {
+    name: 'ɵɵdefineInjectable',
+    moduleName: CORE,
+};
+Identifiers.InjectableDeclaration = {
+    name: 'ɵɵInjectableDeclaration',
+    moduleName: CORE,
+};
+Identifiers.FactoryDeclaration = {
+    name: 'ɵɵFactoryDeclaration',
+    moduleName: CORE,
+};
+Identifiers.getInheritedFactory = {
+    name: 'ɵɵgetInheritedFactory',
+    moduleName: CORE,
+};

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

@@ -0,0 +1,21 @@
+/**
+ * @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 '../output/output_ast';
+export declare function typeWithParameters(type: o.Expression, numParams: number): o.ExpressionType;
+export interface R3Reference {
+    value: o.Expression;
+    type: o.Expression;
+}
+/**
+ * Result of compilation of a render3 code unit, e.g. component, directive, pipe, etc.
+ */
+export interface R3CompiledExpression {
+    expression: o.Expression;
+    type: o.Type;
+    statements: o.Statement[];
+}

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

@@ -0,0 +1,41 @@
+"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.typeWithParameters = 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 o = __importStar(require("../output/output_ast"));
+function typeWithParameters(type, numParams) {
+    if (numParams === 0) {
+        return o.expressionType(type);
+    }
+    const params = [];
+    for (let i = 0; i < numParams; i++) {
+        params.push(o.DYNAMIC_TYPE);
+    }
+    return o.expressionType(type, undefined, params);
+}
+exports.typeWithParameters = typeWithParameters;

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

@@ -0,0 +1,30 @@
+/**
+ * @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 '../../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
+ * property names that are set can be resolved to their documented declaration.
+ */
+export declare class DefinitionMap<T = any> {
+    values: {
+        key: string;
+        quoted: boolean;
+        value: o.Expression;
+    }[];
+    set(key: keyof T, value: o.Expression | null): void;
+    toLiteralMap(): o.LiteralMapExpr;
+}

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

@@ -0,0 +1,57 @@
+"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.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
+ * property names that are set can be resolved to their documented declaration.
+ */
+class DefinitionMap {
+    constructor() {
+        this.values = [];
+    }
+    set(key, value) {
+        if (value) {
+            this.values.push({ key: key, value, quoted: false });
+        }
+    }
+    toLiteralMap() {
+        return o.literalMap(this.values);
+    }
+}
+exports.DefinitionMap = DefinitionMap;