static-injector 4.0.2 → 5.0.0

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

@@ -1,189 +0,0 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbstractClassDeclaration = exports.toFactoryMetadata = exports.wrapTypeReference = exports.wrapFunctionExpressionsInParens = exports.tryUnwrapForwardRef = exports.unwrapExpression = exports.getAngularDecorators = exports.isAngularDecorator = exports.findAngularDecorator = exports.isAngularCore = exports.valueReferenceToExpression = exports.CORE_MODULE = void 0;
-const compiler_1 = require("static-injector/transform/compiler");
-const typescript_1 = __importDefault(require("typescript"));
-/** Module name of the framework core. */
-exports.CORE_MODULE = 'static-injector';
-function valueReferenceToExpression(valueRef) {
-    if (valueRef.kind === 2 /* TypeValueReferenceKind.UNAVAILABLE */) {
-        return null;
-    }
-    else if (valueRef.kind === 0 /* TypeValueReferenceKind.LOCAL */) {
-        const expr = new compiler_1.WrappedNodeExpr(valueRef.expression);
-        return expr;
-    }
-    else {
-        let importExpr = new compiler_1.ExternalExpr({
-            moduleName: valueRef.moduleName,
-            name: valueRef.importedName,
-        });
-        if (valueRef.nestedPath !== null) {
-            for (const property of valueRef.nestedPath) {
-                importExpr = new compiler_1.ReadPropExpr(importExpr, property);
-            }
-        }
-        return importExpr;
-    }
-}
-exports.valueReferenceToExpression = valueReferenceToExpression;
-function isAngularCore(decorator) {
-    return decorator.import !== null && decorator.import.from === exports.CORE_MODULE;
-}
-exports.isAngularCore = isAngularCore;
-function findAngularDecorator(decorators, name, isCore) {
-    return decorators.find((decorator) => isAngularDecorator(decorator, name, isCore));
-}
-exports.findAngularDecorator = findAngularDecorator;
-function isAngularDecorator(decorator, name, isCore) {
-    if (isCore) {
-        return decorator.name === name;
-    }
-    else if (isAngularCore(decorator)) {
-        return decorator.import.name === name;
-    }
-    return false;
-}
-exports.isAngularDecorator = isAngularDecorator;
-function getAngularDecorators(decorators, names, isCore) {
-    return decorators.filter((decorator) => {
-        const name = isCore ? decorator.name : decorator.import?.name;
-        if (name === undefined || !names.includes(name)) {
-            return false;
-        }
-        return isCore || isAngularCore(decorator);
-    });
-}
-exports.getAngularDecorators = getAngularDecorators;
-/**
- * Unwrap a `ts.Expression`, removing outer type-casts or parentheses until the expression is in its
- * lowest level form.
- *
- * For example, the expression "(foo as Type)" unwraps to "foo".
- */
-function unwrapExpression(node) {
-    while (typescript_1.default.isAsExpression(node) || typescript_1.default.isParenthesizedExpression(node)) {
-        node = node.expression;
-    }
-    return node;
-}
-exports.unwrapExpression = unwrapExpression;
-function expandForwardRef(arg) {
-    arg = unwrapExpression(arg);
-    if (!typescript_1.default.isArrowFunction(arg) && !typescript_1.default.isFunctionExpression(arg)) {
-        return null;
-    }
-    const body = arg.body;
-    // Either the body is a ts.Expression directly, or a block with a single return statement.
-    if (typescript_1.default.isBlock(body)) {
-        // Block body - look for a single return statement.
-        if (body.statements.length !== 1) {
-            return null;
-        }
-        const stmt = body.statements[0];
-        if (!typescript_1.default.isReturnStatement(stmt) || stmt.expression === undefined) {
-            return null;
-        }
-        return stmt.expression;
-    }
-    else {
-        // Shorthand body - return as an expression.
-        return body;
-    }
-}
-/**
- * If the given `node` is a forwardRef() expression then resolve its inner value, otherwise return
- * `null`.
- *
- * @param node the forwardRef() expression to resolve
- * @param reflector a ReflectionHost
- * @returns the resolved expression, if the original expression was a forwardRef(), or `null`
- *     otherwise.
- */
-function tryUnwrapForwardRef(node, reflector) {
-    node = unwrapExpression(node);
-    if (!typescript_1.default.isCallExpression(node) || node.arguments.length !== 1) {
-        return null;
-    }
-    const fn = typescript_1.default.isPropertyAccessExpression(node.expression)
-        ? node.expression.name
-        : node.expression;
-    if (!typescript_1.default.isIdentifier(fn)) {
-        return null;
-    }
-    const expr = expandForwardRef(node.arguments[0]);
-    if (expr === null) {
-        return null;
-    }
-    const imp = reflector.getImportOfIdentifier(fn);
-    if (imp === null ||
-        imp.from !== 'static-injector' ||
-        imp.name !== 'forwardRef') {
-        return null;
-    }
-    return expr;
-}
-exports.tryUnwrapForwardRef = tryUnwrapForwardRef;
-const parensWrapperTransformerFactory = (context) => {
-    const visitor = (node) => {
-        const visited = typescript_1.default.visitEachChild(node, visitor, context);
-        if (typescript_1.default.isArrowFunction(visited) || typescript_1.default.isFunctionExpression(visited)) {
-            return typescript_1.default.factory.createParenthesizedExpression(visited);
-        }
-        return visited;
-    };
-    return (node) => typescript_1.default.visitEachChild(node, visitor, context);
-};
-/**
- * Wraps all functions in a given expression in parentheses. This is needed to avoid problems
- * where Tsickle annotations added between analyse and transform phases in Angular may trigger
- * automatic semicolon insertion, e.g. if a function is the expression in a `return` statement.
- * More
- * info can be found in Tsickle source code here:
- * https://github.com/angular/tsickle/blob/d7974262571c8a17d684e5ba07680e1b1993afdd/src/jsdoc_transformer.ts#L1021
- *
- * @param expression Expression where functions should be wrapped in parentheses
- */
-function wrapFunctionExpressionsInParens(expression) {
-    return typescript_1.default.transform(expression, [parensWrapperTransformerFactory])
-        .transformed[0];
-}
-exports.wrapFunctionExpressionsInParens = wrapFunctionExpressionsInParens;
-/**
- * Create an R3Reference for a class.
- *
- * The `value` is the exported declaration of the class from its source file.
- * The `type` is an expression that would be used in the typings (.d.ts) files.
- */
-function wrapTypeReference(reflector, clazz) {
-    const value = new compiler_1.WrappedNodeExpr(clazz.name);
-    const type = value;
-    return { value, type };
-}
-exports.wrapTypeReference = wrapTypeReference;
-function toFactoryMetadata(meta, target) {
-    return {
-        name: meta.name,
-        type: meta.type,
-        typeArgumentCount: meta.typeArgumentCount,
-        deps: meta.deps,
-        target,
-    };
-}
-exports.toFactoryMetadata = toFactoryMetadata;
-function isAbstractClassDeclaration(clazz) {
-    return typescript_1.default.canHaveModifiers(clazz) && clazz.modifiers !== undefined
-        ? clazz.modifiers.some((mod) => mod.kind === typescript_1.default.SyntaxKind.AbstractKeyword)
-        : false;
-}
-exports.isAbstractClassDeclaration = isAbstractClassDeclaration;

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

@@ -1,43 +0,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
- */
-import { R3DependencyMetadata, R3InjectableMetadata } from 'static-injector/transform/compiler';
-import { ClassDeclaration, Decorator, ReflectionHost } from '../../reflection';
-import { AnalysisOutput, CompilationMode, CompileResult, DecoratorHandler, DetectResult } from '../../transform';
-export interface InjectableHandlerData {
-    meta: R3InjectableMetadata;
-    ctorDeps: R3DependencyMetadata[] | 'invalid' | null;
-}
-/**
- * Adapts the `compileInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
- */
-export declare class InjectableDecoratorHandler implements DecoratorHandler<Decorator, InjectableHandlerData, unknown> {
-    private reflector;
-    private isCore;
-    private strictCtorDeps;
-    private includeClassMetadata;
-    private readonly compilationMode;
-    /**
-     * What to do if the injectable already contains a ɵprov property.
-     *
-     * If true then an error diagnostic is reported.
-     * If false then there is no error and a new ɵprov property is not added.
-     */
-    private errorOnDuplicateProv;
-    constructor(reflector: ReflectionHost, isCore: boolean, strictCtorDeps: boolean, includeClassMetadata: boolean, compilationMode: CompilationMode, 
-    /**
-     * What to do if the injectable already contains a ɵprov property.
-     *
-     * If true then an error diagnostic is reported.
-     * If false then there is no error and a new ɵprov property is not added.
-     */
-    errorOnDuplicateProv?: boolean);
-    detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator> | undefined;
-    analyze(node: ClassDeclaration, decorator: Readonly<Decorator>): AnalysisOutput<InjectableHandlerData>;
-    compileFull(node: ClassDeclaration, analysis: Readonly<InjectableHandlerData>): CompileResult[];
-    private compile;
-}

package/transform/compiler-cli/src/ngtsc/annotations/src/injectable.js

@@ -1,277 +0,0 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectableDecoratorHandler = void 0;
-const compiler_1 = require("static-injector/transform/compiler");
-const typescript_1 = __importDefault(require("typescript"));
-const common_1 = require("../../annotations/common");
-const diagnostics_1 = require("../../diagnostics");
-const reflection_1 = require("../../reflection");
-const common_2 = require("../common");
-/**
- * Adapts the `compileInjectable` compiler for `@Injectable` decorators to the Ivy compiler.
- */
-class InjectableDecoratorHandler {
-    reflector;
-    isCore;
-    strictCtorDeps;
-    includeClassMetadata;
-    compilationMode;
-    errorOnDuplicateProv;
-    constructor(reflector, isCore, strictCtorDeps, includeClassMetadata, compilationMode, 
-    /**
-     * What to do if the injectable already contains a ɵprov property.
-     *
-     * If true then an error diagnostic is reported.
-     * If false then there is no error and a new ɵprov property is not added.
-     */
-    errorOnDuplicateProv = true) {
-        this.reflector = reflector;
-        this.isCore = isCore;
-        this.strictCtorDeps = strictCtorDeps;
-        this.includeClassMetadata = includeClassMetadata;
-        this.compilationMode = compilationMode;
-        this.errorOnDuplicateProv = errorOnDuplicateProv;
-    }
-    detect(node, decorators) {
-        if (!decorators) {
-            return undefined;
-        }
-        const decorator = (0, common_2.findAngularDecorator)(decorators, 'Injectable', this.isCore);
-        if (decorator !== undefined) {
-            return {
-                trigger: decorator.node,
-                decorator: decorator,
-                metadata: decorator,
-            };
-        }
-        else {
-            return undefined;
-        }
-    }
-    analyze(node, decorator) {
-        const meta = extractInjectableMetadata(node, decorator, this.reflector);
-        return {
-            analysis: {
-                meta,
-                ctorDeps: extractInjectableCtorDeps(node, meta, decorator, this.reflector, this.isCore, this.strictCtorDeps),
-                // Avoid generating multiple factories if a class has
-                // more Angular decorators, apart from Injectable.
-            },
-        };
-    }
-    compileFull(node, analysis) {
-        return this.compile(common_2.compileNgFactoryDefField, (meta) => (0, compiler_1.compileInjectable)(meta, false), node, analysis);
-    }
-    compile(compileFactoryFn, compileInjectableFn, node, analysis) {
-        const results = [];
-        if (true) {
-            const meta = analysis.meta;
-            const factoryRes = compileFactoryFn((0, common_2.toFactoryMetadata)({ ...meta, deps: analysis.ctorDeps }, compiler_1.FactoryTarget.Injectable));
-            results.push(factoryRes);
-        }
-        const ɵprov = this.reflector
-            .getMembersOfClass(node)
-            .find((member) => member.name === 'ɵprov');
-        if (ɵprov !== undefined && this.errorOnDuplicateProv) {
-            throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.INJECTABLE_DUPLICATE_PROV, ɵprov.nameNode || ɵprov.node || node, 'Injectables cannot contain a static ɵprov property, because the compiler is going to generate one.');
-        }
-        if (ɵprov === undefined) {
-            // Only add a new ɵprov if there is not one already
-            const res = compileInjectableFn(analysis.meta);
-            results.push({
-                name: 'ɵprov',
-                initializer: res.expression,
-                statements: res.statements,
-                type: res.type,
-                deferrableImports: null,
-            });
-        }
-        return results;
-    }
-}
-exports.InjectableDecoratorHandler = InjectableDecoratorHandler;
-/**
- * Read metadata from the `@Injectable` decorator and produce the `IvyInjectableMetadata`, the
- * input metadata needed to run `compileInjectable`.
- *
- * A `null` return value indicates this is @Injectable has invalid data.
- */
-function extractInjectableMetadata(clazz, decorator, reflector) {
-    const name = clazz.name.text;
-    const type = (0, common_2.wrapTypeReference)(reflector, clazz);
-    const typeArgumentCount = reflector.getGenericArityOfClass(clazz) || 0;
-    if (decorator.args === null) {
-        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, decorator.node, '@Injectable must be called');
-    }
-    if (decorator.args.length === 0) {
-        return {
-            name,
-            type,
-            typeArgumentCount,
-            providedIn: (0, compiler_1.createMayBeForwardRefExpression)(new compiler_1.LiteralExpr(null), 0 /* ForwardRefHandling.None */),
-        };
-    }
-    else if (decorator.args.length === 1) {
-        const metaNode = decorator.args[0];
-        // Firstly make sure the decorator argument is an inline literal - if not, it's illegal to
-        // transport references from one location to another. This is the problem that lowering
-        // used to solve - if this restriction proves too undesirable we can re-implement lowering.
-        if (!typescript_1.default.isObjectLiteralExpression(metaNode)) {
-            throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARG_NOT_LITERAL, metaNode, `@Injectable argument must be an object literal`);
-        }
-        // Resolve the fields of the literal into a map of field name to expression.
-        const meta = (0, reflection_1.reflectObjectLiteral)(metaNode);
-        const providedIn = meta.has('providedIn')
-            ? getProviderExpression(meta.get('providedIn'), reflector)
-            : (0, compiler_1.createMayBeForwardRefExpression)(new compiler_1.LiteralExpr(null), 0 /* ForwardRefHandling.None */);
-        let deps = undefined;
-        if ((meta.has('useClass') || meta.has('useFactory')) && meta.has('deps')) {
-            const depsExpr = meta.get('deps');
-            if (!typescript_1.default.isArrayLiteralExpression(depsExpr)) {
-                throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.VALUE_NOT_LITERAL, depsExpr, `@Injectable deps metadata must be an inline array`);
-            }
-            deps = depsExpr.elements.map((dep) => getDep(dep, reflector));
-        }
-        const result = {
-            name,
-            type,
-            typeArgumentCount,
-            providedIn,
-        };
-        if (meta.has('useValue')) {
-            result.useValue = getProviderExpression(meta.get('useValue'), reflector);
-        }
-        else if (meta.has('useExisting')) {
-            result.useExisting = getProviderExpression(meta.get('useExisting'), reflector);
-        }
-        else if (meta.has('useClass')) {
-            result.useClass = getProviderExpression(meta.get('useClass'), reflector);
-            result.deps = deps;
-        }
-        else if (meta.has('useFactory')) {
-            result.useFactory = new compiler_1.WrappedNodeExpr(meta.get('useFactory'));
-            result.deps = deps;
-        }
-        return result;
-    }
-    else {
-        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_ARITY_WRONG, decorator.args[2], 'Too many arguments to @Injectable');
-    }
-}
-/**
- * Get the `R3ProviderExpression` for this `expression`.
- *
- * The `useValue`, `useExisting` and `useClass` properties might be wrapped in a `ForwardRef`, which
- * needs to be unwrapped. This function will do that unwrapping and set a flag on the returned
- * object to indicate whether the value needed unwrapping.
- */
-function getProviderExpression(expression, reflector) {
-    const forwardRefValue = (0, common_2.tryUnwrapForwardRef)(expression, reflector);
-    return (0, compiler_1.createMayBeForwardRefExpression)(new compiler_1.WrappedNodeExpr(forwardRefValue ?? expression), forwardRefValue !== null
-        ? 2 /* ForwardRefHandling.Unwrapped */
-        : 0 /* ForwardRefHandling.None */);
-}
-function extractInjectableCtorDeps(clazz, meta, decorator, reflector, isCore, strictCtorDeps) {
-    if (decorator.args === null) {
-        throw new diagnostics_1.FatalDiagnosticError(diagnostics_1.ErrorCode.DECORATOR_NOT_CALLED, decorator.node, '@Injectable must be called');
-    }
-    let ctorDeps = null;
-    if (decorator.args.length === 0) {
-        // Ideally, using @Injectable() would have the same effect as using @Injectable({...}), and be
-        // subject to the same validation. However, existing Angular code abuses @Injectable, applying
-        // it to things like abstract classes with constructors that were never meant for use with
-        // Angular's DI.
-        //
-        // To deal with this, @Injectable() without an argument is more lenient, and if the
-        // constructor signature does not work for DI then a factory definition (ɵfac) that throws is
-        // generated.
-        if (strictCtorDeps && !(0, common_1.isAbstractClassDeclaration)(clazz)) {
-            ctorDeps = (0, common_2.getValidConstructorDependencies)(clazz, reflector, isCore);
-        }
-        else {
-            ctorDeps = (0, common_2.unwrapConstructorDependencies)((0, common_2.getConstructorDependencies)(clazz, reflector, isCore));
-        }
-        return ctorDeps;
-    }
-    else if (decorator.args.length === 1) {
-        const rawCtorDeps = (0, common_2.getConstructorDependencies)(clazz, reflector, isCore);
-        if (strictCtorDeps &&
-            !(0, common_1.isAbstractClassDeclaration)(clazz) &&
-            requiresValidCtor(meta)) {
-            // Since use* was not provided for a concrete class, validate the deps according to
-            // strictCtorDeps.
-            ctorDeps = (0, common_2.validateConstructorDependencies)(clazz, rawCtorDeps);
-        }
-        else {
-            ctorDeps = (0, common_2.unwrapConstructorDependencies)(rawCtorDeps);
-        }
-    }
-    return ctorDeps;
-}
-function requiresValidCtor(meta) {
-    return (meta.useValue === undefined &&
-        meta.useExisting === undefined &&
-        meta.useClass === undefined &&
-        meta.useFactory === undefined);
-}
-function getDep(dep, reflector) {
-    const meta = {
-        token: new compiler_1.WrappedNodeExpr(dep),
-        attributeNameType: null,
-        optional: false,
-        self: false,
-        skipSelf: false,
-    };
-    function maybeUpdateDecorator(dec, reflector, token) {
-        const source = reflector.getImportOfIdentifier(dec);
-        if (source === null || source.from !== 'static-injector') {
-            return false;
-        }
-        switch (source.name) {
-            case 'Inject':
-                if (token !== undefined) {
-                    meta.token = new compiler_1.WrappedNodeExpr(token);
-                }
-                break;
-            case 'Optional':
-                meta.optional = true;
-                break;
-            case 'SkipSelf':
-                meta.skipSelf = true;
-                break;
-            case 'Self':
-                meta.self = true;
-                break;
-            default:
-                return false;
-        }
-        return true;
-    }
-    if (typescript_1.default.isArrayLiteralExpression(dep)) {
-        dep.elements.forEach((el) => {
-            let isDecorator = false;
-            if (typescript_1.default.isIdentifier(el)) {
-                isDecorator = maybeUpdateDecorator(el, reflector);
-            }
-            else if (typescript_1.default.isNewExpression(el) && typescript_1.default.isIdentifier(el.expression)) {
-                const token = (el.arguments && el.arguments.length > 0 && el.arguments[0]) ||
-                    undefined;
-                isDecorator = maybeUpdateDecorator(el.expression, reflector, token);
-            }
-            if (!isDecorator) {
-                meta.token = new compiler_1.WrappedNodeExpr(el);
-            }
-        });
-    }
-    return meta;
-}

package/transform/compiler-cli/src/ngtsc/diagnostics/error.d.ts

@@ -1,24 +0,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
- */
-import * as ts from 'typescript';
-import { ErrorCode } from './error_code';
-export declare class FatalDiagnosticError {
-    readonly code: ErrorCode;
-    readonly node: ts.Node;
-    readonly message: string | ts.DiagnosticMessageChain;
-    readonly relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined;
-    constructor(code: ErrorCode, node: ts.Node, message: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[] | undefined);
-    /**
-     * @internal
-     */
-    _isFatalDiagnosticError: boolean;
-    toDiagnostic(): ts.DiagnosticWithLocation;
-}
-export declare function makeDiagnostic(code: ErrorCode, node: ts.Node, messageText: string | ts.DiagnosticMessageChain, relatedInformation?: ts.DiagnosticRelatedInformation[]): ts.DiagnosticWithLocation;
-export declare function makeRelatedInformation(node: ts.Node, messageText: string): ts.DiagnosticRelatedInformation;
-export declare function isFatalDiagnosticError(err: any): err is FatalDiagnosticError;

package/transform/compiler-cli/src/ngtsc/diagnostics/error.js

@@ -1,84 +0,0 @@
-"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 __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.isFatalDiagnosticError = exports.makeRelatedInformation = exports.makeDiagnostic = exports.FatalDiagnosticError = void 0;
-const ts = __importStar(require("typescript"));
-const error_code_1 = require("./error_code");
-class FatalDiagnosticError {
-    code;
-    node;
-    message;
-    relatedInformation;
-    constructor(code, node, message, relatedInformation) {
-        this.code = code;
-        this.node = node;
-        this.message = message;
-        this.relatedInformation = relatedInformation;
-    }
-    /**
-     * @internal
-     */
-    _isFatalDiagnosticError = true;
-    toDiagnostic() {
-        return makeDiagnostic(this.code, this.node, this.message, this.relatedInformation);
-    }
-}
-exports.FatalDiagnosticError = FatalDiagnosticError;
-function makeDiagnostic(code, node, messageText, relatedInformation) {
-    node = ts.getOriginalNode(node);
-    return {
-        category: ts.DiagnosticCategory.Error,
-        code: (0, error_code_1.ngErrorCode)(code),
-        file: ts.getOriginalNode(node).getSourceFile(),
-        start: node.getStart(undefined, false),
-        length: node.getWidth(),
-        messageText,
-        relatedInformation,
-    };
-}
-exports.makeDiagnostic = makeDiagnostic;
-function makeRelatedInformation(node, messageText) {
-    node = ts.getOriginalNode(node);
-    return {
-        category: ts.DiagnosticCategory.Message,
-        code: 0,
-        file: node.getSourceFile(),
-        start: node.getStart(),
-        length: node.getWidth(),
-        messageText,
-    };
-}
-exports.makeRelatedInformation = makeRelatedInformation;
-function isFatalDiagnosticError(err) {
-    return err._isFatalDiagnosticError === true;
-}
-exports.isFatalDiagnosticError = isFatalDiagnosticError;