static-injector 1.0.8

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

@@ -0,0 +1,50 @@
+/**
+ * @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 class ParseLocation {
+    file: ParseSourceFile;
+    offset: number;
+    line: number;
+    col: number;
+    constructor(file: ParseSourceFile, offset: number, line: number, col: number);
+}
+export declare class ParseSourceFile {
+    content: string;
+    url: string;
+    constructor(content: string, url: string);
+}
+export declare class ParseSourceSpan {
+    start: ParseLocation;
+    end: ParseLocation;
+    fullStart: ParseLocation;
+    details: string | null;
+    /**
+     * Create an object that holds information about spans of tokens/nodes captured during
+     * lexing/parsing of text.
+     *
+     * @param start
+     * The location of the start of the span (having skipped leading trivia).
+     * Skipping leading trivia makes source-spans more "user friendly", since things like HTML
+     * elements will appear to begin at the start of the opening tag, rather than at the start of any
+     * leading trivia, which could include newlines.
+     *
+     * @param end
+     * The location of the end of the span.
+     *
+     * @param fullStart
+     * The start of the token without skipping the leading trivia.
+     * This is used by tooling that splits tokens further, such as extracting Angular interpolations
+     * from text tokens. Such tooling creates new source-spans relative to the original token's
+     * source-span. If leading trivia characters have been skipped then the new source-spans may be
+     * incorrectly offset.
+     *
+     * @param details
+     * Additional information (such as identifier names) that should be associated with the span.
+     */
+    constructor(start: ParseLocation, end: ParseLocation, fullStart?: ParseLocation, details?: string | null);
+    toString(): string;
+}

package/transform/compiler/src/parse_util.js

@@ -0,0 +1,61 @@
+"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.ParseSourceSpan = exports.ParseSourceFile = exports.ParseLocation = void 0;
+class ParseLocation {
+    constructor(file, offset, line, col) {
+        this.file = file;
+        this.offset = offset;
+        this.line = line;
+        this.col = col;
+    }
+}
+exports.ParseLocation = ParseLocation;
+class ParseSourceFile {
+    constructor(content, url) {
+        this.content = content;
+        this.url = url;
+    }
+}
+exports.ParseSourceFile = ParseSourceFile;
+class ParseSourceSpan {
+    /**
+     * Create an object that holds information about spans of tokens/nodes captured during
+     * lexing/parsing of text.
+     *
+     * @param start
+     * The location of the start of the span (having skipped leading trivia).
+     * Skipping leading trivia makes source-spans more "user friendly", since things like HTML
+     * elements will appear to begin at the start of the opening tag, rather than at the start of any
+     * leading trivia, which could include newlines.
+     *
+     * @param end
+     * The location of the end of the span.
+     *
+     * @param fullStart
+     * The start of the token without skipping the leading trivia.
+     * This is used by tooling that splits tokens further, such as extracting Angular interpolations
+     * from text tokens. Such tooling creates new source-spans relative to the original token's
+     * source-span. If leading trivia characters have been skipped then the new source-spans may be
+     * incorrectly offset.
+     *
+     * @param details
+     * Additional information (such as identifier names) that should be associated with the span.
+     */
+    constructor(start, end, fullStart = start, details = null) {
+        this.start = start;
+        this.end = end;
+        this.fullStart = fullStart;
+        this.details = details;
+    }
+    toString() {
+        return this.start.file.content.substring(this.start.offset, this.end.offset);
+    }
+}
+exports.ParseSourceSpan = ParseSourceSpan;

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

@@ -0,0 +1,166 @@
+/**
+ * @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 interface R3PartialDeclaration {
+    /**
+     * The minimum version of the compiler that can process this partial declaration.
+     */
+    minVersion: string;
+    /**
+     * Version number of the Angular compiler that was used to compile this declaration. The linker
+     * will be able to detect which version a library is using and interpret its metadata accordingly.
+     */
+    version: string;
+    /**
+     * A reference to the `static-injector` ES module, which allows access
+     * to all Angular exports, including Ivy instructions.
+     */
+    ngImport: o.Expression;
+    /**
+     * Reference to the decorated class, which is subject to this partial declaration.
+     */
+    type: o.Expression;
+}
+/**
+ * Describes the shape of the objects that the `ɵɵngDeclareInjector()` accepts.
+ */
+export interface R3DeclareInjectorMetadata extends R3PartialDeclaration {
+    /**
+     * The list of providers provided by the injector.
+     */
+    providers?: o.Expression;
+    /**
+     * The list of imports into the injector.
+     */
+    imports?: o.Expression[];
+}
+/**
+ * Describes the shape of the object that the `ɵɵngDeclareFactory()` function accepts.
+ *
+ * This interface serves primarily as documentation, as conformance to this interface is not
+ * enforced during linking.
+ */
+export interface R3DeclareFactoryMetadata extends R3PartialDeclaration {
+    /**
+     * A collection of dependencies that this factory relies upon.
+     *
+     * If this is `null`, then the type's constructor is nonexistent and will be inherited from an
+     * ancestor of the type.
+     *
+     * If this is `'invalid'`, then one or more of the parameters wasn't resolvable and any attempt to
+     * use these deps will result in a runtime error.
+     */
+    deps: R3DeclareDependencyMetadata[] | 'invalid' | null;
+    /**
+     * Type of the target being created by the factory.
+     */
+    target: FactoryTarget;
+}
+export declare enum FactoryTarget {
+    Directive = 0,
+    Component = 1,
+    Injectable = 2,
+    Pipe = 3,
+    NgModule = 4
+}
+/**
+ * Describes the shape of the object that the `ɵɵngDeclareInjectable()` function accepts.
+ *
+ * This interface serves primarily as documentation, as conformance to this interface is not
+ * enforced during linking.
+ */
+export interface R3DeclareInjectableMetadata extends R3PartialDeclaration {
+    /**
+     * If provided, specifies that the declared injectable belongs to a particular injector:
+     * - `InjectorType` such as `NgModule`,
+     * - `'root'` the root injector
+     * - `'any'` all injectors.
+     * If not provided, then it does not belong to any injector. Must be explicitly listed in the
+     * providers of an injector.
+     */
+    providedIn?: o.Expression;
+    /**
+     * If provided, an expression that evaluates to a class to use when creating an instance of this
+     * injectable.
+     */
+    useClass?: o.Expression;
+    /**
+     * If provided, an expression that evaluates to a function to use when creating an instance of
+     * this injectable.
+     */
+    useFactory?: o.Expression;
+    /**
+     * If provided, an expression that evaluates to a token of another injectable that this injectable
+     * aliases.
+     */
+    useExisting?: o.Expression;
+    /**
+     * If provided, an expression that evaluates to the value of the instance of this injectable.
+     */
+    useValue?: o.Expression;
+    /**
+     * An array of dependencies to support instantiating this injectable via `useClass` or
+     * `useFactory`.
+     */
+    deps?: R3DeclareDependencyMetadata[];
+}
+/**
+ * Metadata indicating how a dependency should be injected into a factory.
+ */
+export interface R3DeclareDependencyMetadata {
+    /**
+     * An expression representing the token or value to be injected, or `null` if the dependency is
+     * not valid.
+     *
+     * If this dependency is due to the `@Attribute()` decorator, then this is an expression
+     * evaluating to the name of the attribute.
+     */
+    token: o.Expression | null;
+    /**
+     * Whether the dependency is injecting an attribute value.
+     * Default: false.
+     */
+    attribute?: boolean;
+    /**
+     * Whether the dependency has an @Optional qualifier.
+     * Default: false,
+     */
+    optional?: boolean;
+    /**
+     * Whether the dependency has an @Self qualifier.
+     * Default: false,
+     */
+    self?: boolean;
+    /**
+     * Whether the dependency has an @SkipSelf qualifier.
+     * Default: false,
+     */
+    skipSelf?: boolean;
+}
+/**
+ * Describes the shape of the object that the `ɵɵngDeclareClassMetadata()` function accepts.
+ *
+ * This interface serves primarily as documentation, as conformance to this interface is not
+ * enforced during linking.
+ */
+export interface R3DeclareClassMetadata extends R3PartialDeclaration {
+    /**
+     * The Angular decorators of the class.
+     */
+    decorators: o.Expression;
+    /**
+     * Optionally specifies the constructor parameters, their types and the Angular decorators of each
+     * parameter. This property is omitted if the class does not have a constructor.
+     */
+    ctorParameters?: o.Expression;
+    /**
+     * Optionally specifies the Angular decorators applied to the class properties. This property is
+     * omitted if no properties have any decorators.
+     */
+    propDecorators?: o.Expression;
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FactoryTarget = void 0;
+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 = {}));

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

@@ -0,0 +1,16 @@
+/**
+ * @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";
+/**
+ * Generate an expression that has the given `expr` wrapped in the following form:
+ *
+ * ```
+ * forwardRef(() => expr)
+ * ```
+ */
+export declare function generateForwardRef(expr: o.Expression): o.Expression;

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

@@ -0,0 +1,44 @@
+"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.generateForwardRef = 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"));
+const r3_identifiers_1 = require("../r3_identifiers");
+/**
+ * Generate an expression that has the given `expr` wrapped in the following form:
+ *
+ * ```
+ * forwardRef(() => expr)
+ * ```
+ */
+function generateForwardRef(expr) {
+    return o
+        .importExpr(r3_identifiers_1.Identifiers.forwardRef)
+        .callFn([o.fn([], [new o.ReturnStatement(expr)])]);
+}
+exports.generateForwardRef = generateForwardRef;

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

@@ -0,0 +1,97 @@
+/**
+ * @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 { R3CompiledExpression, R3Reference } from './util';
+/**
+ * Metadata required by the factory generator to generate a `factory` function for a type.
+ */
+export interface R3ConstructorFactoryMetadata {
+    /**
+     * String name of the type being generated (used to name the factory function).
+     */
+    name: string;
+    /**
+     * An expression representing the interface type being constructed.
+     */
+    type: R3Reference;
+    /**
+     * An expression representing the constructor type, intended for use within a class definition
+     * itself.
+     *
+     * 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;
+    /** Number of arguments for the `type`. */
+    typeArgumentCount: number;
+    /**
+     * Regardless of whether `fnOrClass` is a constructor function or a user-defined factory, it
+     * may have 0 or more parameters, which will be injected according to the `R3DependencyMetadata`
+     * for those parameters. If this is `null`, then the type's constructor is nonexistent and will
+     * be inherited from `fnOrClass` which is interpreted as the current type. If this is `'invalid'`,
+     * then one or more of the parameters wasn't resolvable and any attempt to use these deps will
+     * result in a runtime error.
+     */
+    deps: R3DependencyMetadata[] | 'invalid' | null;
+    /**
+     * Type of the target being created by the factory.
+     */
+    target: FactoryTarget;
+}
+export declare enum R3FactoryDelegateType {
+    Class = 0,
+    Function = 1
+}
+export interface R3DelegatedFnOrClassMetadata extends R3ConstructorFactoryMetadata {
+    delegate: outputAst.Expression;
+    delegateType: R3FactoryDelegateType;
+    delegateDeps: R3DependencyMetadata[];
+}
+export interface R3ExpressionFactoryMetadata extends R3ConstructorFactoryMetadata {
+    expression: outputAst.Expression;
+}
+export declare type R3FactoryMetadata = R3ConstructorFactoryMetadata | R3DelegatedFnOrClassMetadata | R3ExpressionFactoryMetadata;
+export declare enum FactoryTarget {
+    Directive = 0,
+    Component = 1,
+    Injectable = 2,
+    Pipe = 3,
+    NgModule = 4
+}
+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;
+    /**
+     * 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;
+    /**
+     * Whether the dependency has an @Optional qualifier.
+     */
+    optional: boolean;
+    /**
+     * Whether the dependency has an @Self qualifier.
+     */
+    self: boolean;
+    /**
+     * Whether the dependency has an @SkipSelf qualifier.
+     */
+    skipSelf: boolean;
+}
+/**
+ * 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 isDelegatedFactoryMetadata(meta: R3FactoryMetadata): meta is R3DelegatedFnOrClassMetadata;
+export declare function isExpressionFactoryMetadata(meta: R3FactoryMetadata): meta is R3ExpressionFactoryMetadata;