static-injector 2.0.0 → 2.1.1

package/import/typings/util/array_utils.d.ts

@@ -1,10 +1,18 @@
-/**
- * @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
- */
 export declare function deepForEach<T>(input: (T | any[])[], fn: (value: T) => void): void;
 export declare function newArray<T = any>(size: number): T[];
 export declare function newArray<T>(size: number, value: T): T[];
+/**
+ * `KeyValueArray` is an array where even positions contain keys and odd positions contain values.
+ *
+ * `KeyValueArray` provides a very efficient way of iterating over its contents. For small
+ * sets (~10) the cost of binary searching an `KeyValueArray` has about the same performance
+ * characteristics that of a `Map` with significantly better memory footprint.
+ *
+ * If used as a `Map` the keys are stored in alphabetical order so that they can be binary searched
+ * for retrieval.
+ *
+ * See: `keyValueArraySet`, `keyValueArrayGet`, `keyValueArrayIndexOf`, `keyValueArrayDelete`.
+ */
+export interface KeyValueArray<VALUE> extends Array<VALUE | string> {
+    __brand__: 'array-map';
+}

package/import/typings/util/decorators.d.ts

@@ -24,4 +24,5 @@ export interface TypeDecorator {
     <T extends Type<any>>(type: T): T;
     (target: Object, propertyKey?: string | symbol, parameterIndex?: number): void;
 }
-export declare function makeParamDecorator(name: string, props?: (...args: any[]) => any): any;
+export declare const PARAMETERS = "__parameters__";
+export declare function makeParamDecorator(name: string, props?: (...args: any[]) => any, parentClass?: any): any;

package/import/typings/util/empty.d.ts

@@ -11,4 +11,5 @@
  * allows for identity checks against these values to be consistently used by the framework
  * code.
  */
+export declare const EMPTY_OBJ: {};
 export declare const EMPTY_ARRAY: any[];

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "static-injector",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "Angular的静态注入器独立使用版本",
   "keywords": [
     "angular",
     "injector",
     "typescript",
-    "typescript 4.8",
+    "typescript 4.9",
     "injectable",
     "static-inject"
   ],
@@ -29,7 +29,7 @@
   "author": "wszgrcy",
   "license": "MIT",
   "peerDependencies": {
-    "typescript": "^4.0.0"
+    "typescript": "^4.9.3"
   },
   "devDependencies": {},
   "sideEffects": false

package/transform/compiler/compiler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @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
+ */
+export * from './public_api';

package/transform/compiler/compiler.js

@@ -0,0 +1,28 @@
+"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;
+    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 });
+// This file is not used to build this module. It is only used during editing
+// by the TypeScript language service and during build for verification. `ngc`
+// replaces this file with production index.ts when it rewrites private symbol
+// names.
+__exportStar(require("./public_api"), exports);

package/transform/compiler/index.d.ts

@@ -1,5 +1,8 @@
-export * from './src/injectable_compiler_2';
-export * from './src/render3/r3_factory';
-export * from './src/output/output_ast';
-export * from './src/render3/util';
-export * from './src/parse_util';
+/**
+ * @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
+ */
+export * from './compiler';

package/transform/compiler/index.js

@@ -1,4 +1,11 @@
 "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;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,8 +21,8 @@ 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/injectable_compiler_2"), exports);
-__exportStar(require("./src/render3/r3_factory"), exports);
-__exportStar(require("./src/output/output_ast"), exports);
-__exportStar(require("./src/render3/util"), exports);
-__exportStar(require("./src/parse_util"), exports);
+// This file is not used to build this module. It is only used during editing
+// by the TypeScript language service and during build for verification. `ngc`
+// replaces this file with production index.ts when it rewrites private symbol
+// names.
+__exportStar(require("./compiler"), exports);

package/transform/compiler/public_api.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
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+export * from './src/compiler';

package/transform/compiler/public_api.js

@@ -0,0 +1,30 @@
+"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;
+    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 });
+/**
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+__exportStar(require("./src/compiler"), exports);
+// This file only reexports content of the `src` folder. Keep it that way.

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

@@ -0,0 +1,27 @@
+/**
+ * @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
+ */
+/**
+ * @module
+ * @description
+ * Entry point for all APIs of the compiler package.
+ *
+ * <div class="callout is-critical">
+ *   <header>Unstable APIs</header>
+ *   <p>
+ *     All compiler apis are currently considered experimental and private!
+ *   </p>
+ *   <p>
+ *     We expect the APIs in this package to keep on changing. Do not rely on them.
+ *   </p>
+ * </div>
+ */
+export * from './injectable_compiler_2';
+export * from './render3/r3_factory';
+export * from './output/output_ast';
+export * from './render3/util';
+export * from './parse_util';

package/transform/compiler/src/compiler.js

@@ -0,0 +1,47 @@
+"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;
+    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 });
+//////////////////////////////////////
+// THIS FILE HAS GLOBAL SIDE EFFECT //
+//       (see bottom of file)       //
+//////////////////////////////////////
+/**
+ * @module
+ * @description
+ * Entry point for all APIs of the compiler package.
+ *
+ * <div class="callout is-critical">
+ *   <header>Unstable APIs</header>
+ *   <p>
+ *     All compiler apis are currently considered experimental and private!
+ *   </p>
+ *   <p>
+ *     We expect the APIs in this package to keep on changing. Do not rely on them.
+ *   </p>
+ * </div>
+ */
+__exportStar(require("./injectable_compiler_2"), exports);
+__exportStar(require("./render3/r3_factory"), exports);
+__exportStar(require("./output/output_ast"), exports);
+__exportStar(require("./render3/util"), exports);
+__exportStar(require("./parse_util"), exports);

package/transform/compiler/src/output/output_ast.d.ts

@@ -446,7 +446,7 @@ export declare const enum JSDocTagName {
     Meaning = "meaning",
     Suppress = "suppress"
 }
-export declare type JSDocTag = {
+export type JSDocTag = {
     tagName: JSDocTagName | string;
     text?: string;
 } | {

package/transform/compiler/src/render3/partial/api.d.ts

@@ -17,7 +17,7 @@ export interface R3PartialDeclaration {
      */
     version: string;
     /**
-     * A reference to the `static-injector` ES module, which allows access
+     * A reference to the `@angular/core` ES module, which allows access
      * to all Angular exports, including Ivy instructions.
      */
     ngImport: o.Expression;

package/transform/compiler/src/render3/partial/api.js

@@ -1,4 +1,11 @@
 "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.FactoryTarget = void 0;
 var FactoryTarget;

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

@@ -1,11 +1,4 @@
-/**
- * @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 outputAst from '../output/output_ast';
+import * as o from '../output/output_ast';
 import { R3CompiledExpression, R3Reference } from './util';
 /**
  * Metadata required by the factory generator to generate a `factory` function for a type.
@@ -26,7 +19,7 @@ export interface R3ConstructorFactoryMetadata {
      * This can differ from the outer `type` if the class is being compiled by ngcc and is inside
      * an IIFE structure that uses a different name internally.
      */
-    internalType: outputAst.Expression;
+    internalType: o.Expression;
     /** Number of arguments for the `type`. */
     typeArgumentCount: number;
     /**
@@ -48,14 +41,14 @@ export declare enum R3FactoryDelegateType {
     Function = 1
 }
 export interface R3DelegatedFnOrClassMetadata extends R3ConstructorFactoryMetadata {
-    delegate: outputAst.Expression;
+    delegate: o.Expression;
     delegateType: R3FactoryDelegateType;
     delegateDeps: R3DependencyMetadata[];
 }
 export interface R3ExpressionFactoryMetadata extends R3ConstructorFactoryMetadata {
-    expression: outputAst.Expression;
+    expression: o.Expression;
 }
-export declare type R3FactoryMetadata = R3ConstructorFactoryMetadata | R3DelegatedFnOrClassMetadata | R3ExpressionFactoryMetadata;
+export type R3FactoryMetadata = R3ConstructorFactoryMetadata | R3DelegatedFnOrClassMetadata | R3ExpressionFactoryMetadata;
 export declare enum FactoryTarget {
     Directive = 0,
     Component = 1,
@@ -68,13 +61,13 @@ export interface R3DependencyMetadata {
      * An expression representing the token or value to be injected.
      * Or `null` if the dependency could not be resolved - making it invalid.
      */
-    token: outputAst.Expression | null;
+    token: o.Expression | null;
     /**
      * If an @Attribute decorator is present, this is the literal type of the attribute name, or
      * the unknown type if no literal type is available (e.g. the attribute name is an expression).
      * Otherwise it is null;
      */
-    attributeNameType: outputAst.Expression | null;
+    attributeNameType: o.Expression | null;
     /**
      * Whether the dependency has an @Optional qualifier.
      */
@@ -92,6 +85,6 @@ export interface R3DependencyMetadata {
  * Construct a factory function expression for the given `R3FactoryMetadata`.
  */
 export declare function compileFactoryFunction(meta: R3FactoryMetadata): R3CompiledExpression;
-export declare function createFactoryType(meta: R3FactoryMetadata): outputAst.ExpressionType;
+export declare function createFactoryType(meta: R3FactoryMetadata): o.ExpressionType;
 export declare function isDelegatedFactoryMetadata(meta: R3FactoryMetadata): meta is R3DelegatedFnOrClassMetadata;
 export declare function isExpressionFactoryMetadata(meta: R3FactoryMetadata): meta is R3ExpressionFactoryMetadata;

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

@@ -1,11 +1,4 @@
 "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;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -31,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 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 o = __importStar(require("../output/output_ast"));
 const r3_identifiers_1 = require("../render3/r3_identifiers");
 const util_1 = require("./util");
 var R3FactoryDelegateType;
@@ -51,7 +44,7 @@ var FactoryTarget;
  * Construct a factory function expression for the given `R3FactoryMetadata`.
  */
 function compileFactoryFunction(meta) {
-    const t = outputAst.variable('t');
+    const t = o.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
@@ -59,29 +52,29 @@ function compileFactoryFunction(meta) {
     // 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)
+        ? new o.BinaryOperatorExpr(o.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));
+            ctorExpr = new o.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`);
+        baseFactoryVar = o.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 r = o.variable('r');
+        body.push(r.set(o.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()]));
+            : o.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt();
+        body.push(o.ifStmt(t, [ctorStmt], [r.set(nonCtorExpr).toStmt()]));
         return r;
     }
     if (isDelegatedFactoryMetadata(meta)) {
@@ -90,8 +83,8 @@ function compileFactoryFunction(meta) {
         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);
+            ? o.InstantiateExpr
+            : o.InvokeFunctionExpr)(meta.delegate, delegateArgs);
         retExpr = makeConditionalFactory(factoryExpr);
     }
     else if (isExpressionFactoryMetadata(meta)) {
@@ -103,29 +96,29 @@ function compileFactoryFunction(meta) {
     }
     if (retExpr === null) {
         // The expression cannot be formed so render an `ɵɵinvalidFactory()` call.
-        body.push(outputAst.importExpr(r3_identifiers_1.Identifiers.invalidFactory).callFn([]).toStmt());
+        body.push(o.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
+        const getInheritedFactoryCall = o
             .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])));
+        const baseFactory = new o.BinaryOperatorExpr(o.BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
+        body.push(new o.ReturnStatement(baseFactory.callFn([typeForCtor])));
     }
     else {
         // This is straightforward factory, just return it.
-        body.push(new outputAst.ReturnStatement(retExpr));
+        body.push(new o.ReturnStatement(retExpr));
     }
-    let factoryFn = outputAst.fn([new outputAst.FnParam('t', outputAst.DYNAMIC_TYPE)], body, outputAst.INFERRED_TYPE, undefined, `${meta.name}_Factory`);
+    let factoryFn = o.fn([new o.FnParam('t', o.DYNAMIC_TYPE)], body, o.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
+        factoryFn = o
             .fn([], [
-            new outputAst.DeclareVarStmt(baseFactoryVar.name),
-            new outputAst.ReturnStatement(factoryFn),
+            new o.DeclareVarStmt(baseFactoryVar.name),
+            new o.ReturnStatement(factoryFn),
         ])
             .callFn([], /* sourceSpan */ undefined, /* pure */ true);
     }
@@ -139,8 +132,8 @@ 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, [
+        : o.NONE_TYPE;
+    return o.expressionType(o.importExpr(r3_identifiers_1.Identifiers.FactoryDeclaration, [
         (0, util_1.typeWithParameters)(meta.type.type, meta.typeArgumentCount),
         ctorDepsType,
     ]));
@@ -152,29 +145,29 @@ function injectDependencies(deps, target) {
 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)]);
+        return o.importExpr(r3_identifiers_1.Identifiers.invalidFactoryDep).callFn([o.literal(index)]);
     }
     else if (dep.attributeNameType === null) {
         // Build up the injection flags according to the metadata.
         const flags = 0 /* InjectFlags.Default */ |
             (dep.self ? 2 /* InjectFlags.Self */ : 0) |
             (dep.skipSelf ? 4 /* InjectFlags.SkipSelf */ : 0) |
-            (dep.optional ? 8 /* InjectFlags.Optional */ : 0);
+            0 |
+            (dep.optional ? 8 /* InjectFlags.Optional */ : 0) |
+            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 /* InjectFlags.Default */ || dep.optional
-            ? outputAst.literal(flags)
-            : null;
+        let flagsParam = flags !== 0 /* InjectFlags.Default */ || dep.optional ? o.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);
+        return o.importExpr(injectFn).callFn(injectArgs);
+    }
+    else {
     }
 }
 function createCtorDepsType(deps) {
@@ -186,40 +179,28 @@ function createCtorDepsType(deps) {
             return type;
         }
         else {
-            return outputAst.literal(null);
+            return o.literal(null);
         }
     });
     if (hasTypes) {
-        return outputAst.expressionType(outputAst.literalArr(attributeTypes));
+        return o.expressionType(o.literalArr(attributeTypes));
     }
     else {
-        return outputAst.NONE_TYPE;
+        return o.NONE_TYPE;
     }
 }
 function createCtorDepType(dep) {
     const entries = [];
     if (dep.optional) {
-        entries.push({
-            key: 'optional',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'optional', value: o.literal(true), quoted: false });
     }
     if (dep.self) {
-        entries.push({
-            key: 'self',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'self', value: o.literal(true), quoted: false });
     }
     if (dep.skipSelf) {
-        entries.push({
-            key: 'skipSelf',
-            value: outputAst.literal(true),
-            quoted: false,
-        });
+        entries.push({ key: 'skipSelf', value: o.literal(true), quoted: false });
     }
-    return entries.length > 0 ? outputAst.literalMap(entries) : null;
+    return entries.length > 0 ? o.literalMap(entries) : null;
 }
 function isDelegatedFactoryMetadata(meta) {
     return meta.delegateType !== undefined;

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

@@ -6,14 +6,6 @@
  * 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

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

@@ -32,14 +32,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 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

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

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+export * from './src/di';
+export * from './src/factory';
+export * from './src/util';

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

@@ -0,0 +1,26 @@
+"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;
+    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/di"), exports);
+__exportStar(require("./src/factory"), exports);
+__exportStar(require("./src/util"), exports);