@angular/tsc-wrapped

@angular/tsc-wrapped

Version 4.4.6
Published 6 years ago
1 dependency
MIT license

Install

npm i @angular/tsc-wrapped

yarn add @angular/tsc-wrapped

pnpm add @angular/tsc-wrapped

Overview

Wraps the tsc CLI, allowing extensions.

Index

Variables

variable VERSION

const VERSION: number;

Copyright Google Inc. 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

Functions

function createBundleIndexHost

createBundleIndexHost: (
    ngOptions: NgOptions,
    rootFiles: string[],
    host: ts.CompilerHost
) => { host: ts.CompilerHost; indexName?: string; errors?: ts.Diagnostic[] };

function isClassMetadata

isClassMetadata: (value: any) => value is ClassMetadata;

function isConstructorMetadata

isConstructorMetadata: (value: any) => value is ConstructorMetadata;

function isFunctionMetadata

isFunctionMetadata: (value: any) => value is FunctionMetadata;

function isInterfaceMetadata

isInterfaceMetadata: (value: any) => value is InterfaceMetadata;

function isMemberMetadata

isMemberMetadata: (value: any) => value is MemberMetadata;

function isMetadataError

isMetadataError: (value: any) => value is MetadataError;

function isMetadataGlobalReferenceExpression

isMetadataGlobalReferenceExpression: (
    value: any
) => value is MetadataGlobalReferenceExpression;

function isMetadataImportDefaultReference

isMetadataImportDefaultReference: (
    value: any
) => value is MetadataImportedDefaultReferenceExpression;

function isMetadataImportedSymbolReferenceExpression

isMetadataImportedSymbolReferenceExpression: (
    value: any
) => value is MetadataImportedSymbolReferenceExpression;

function isMetadataModuleReferenceExpression

isMetadataModuleReferenceExpression: (
    value: any
) => value is MetadataModuleReferenceExpression;

function isMetadataSymbolicBinaryExpression

isMetadataSymbolicBinaryExpression: (
    value: any
) => value is MetadataSymbolicBinaryExpression;

function isMetadataSymbolicCallExpression

isMetadataSymbolicCallExpression: (
    value: any
) => value is MetadataSymbolicCallExpression;

function isMetadataSymbolicExpression

isMetadataSymbolicExpression: (
    value: any
) => value is MetadataSymbolicExpression;

function isMetadataSymbolicIfExpression

isMetadataSymbolicIfExpression: (
    value: any
) => value is MetadataSymbolicIfExpression;

function isMetadataSymbolicIndexExpression

isMetadataSymbolicIndexExpression: (
    value: any
) => value is MetadataSymbolicIndexExpression;

function isMetadataSymbolicPrefixExpression

isMetadataSymbolicPrefixExpression: (
    value: any
) => value is MetadataSymbolicPrefixExpression;

function isMetadataSymbolicReferenceExpression

isMetadataSymbolicReferenceExpression: (
    value: any
) => value is MetadataSymbolicReferenceExpression;

function isMetadataSymbolicSelectExpression

isMetadataSymbolicSelectExpression: (
    value: any
) => value is MetadataSymbolicSelectExpression;

function isMetadataSymbolicSpreadExpression

isMetadataSymbolicSpreadExpression: (
    value: any
) => value is MetadataSymbolicSpreadExpression;

function isMethodMetadata

isMethodMetadata: (value: any) => value is MethodMetadata;

function isModuleMetadata

isModuleMetadata: (value: any) => value is ModuleMetadata;

function main

main: (
    project: string | VinylFile,
    cliOptions: CliOptions,
    codegen?: CodegenExtension,
    options?: ts.CompilerOptions
) => Promise<any>;

function privateEntriesToIndex

privateEntriesToIndex: (index: string, privates: BundlePrivateEntry[]) => string;

Classes

class CliOptions

class CliOptions {}

Copyright Google Inc. 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

constructor

constructor({ basePath }: { basePath?: string });

property basePath

basePath: string;

class CollectorOptions

class CollectorOptions {}

A set of collector options to use when collecting metadata.

property quotedNames

quotedNames?: boolean;

Collect a hidden field "$quoted$" in objects literals that record when the key was quoted in the source.

property verboseInvalidExpression

verboseInvalidExpression?: boolean;

Do not simplify invalid expressions.

property version

version?: number;

Version of the metadata to collect.

class CompilerHostAdapter

class CompilerHostAdapter implements MetadataBundlerHost {}

constructor

constructor(host: ts.CompilerHost);

method getMetadataFor

getMetadataFor: (fileName: string) => ModuleMetadata;

class I18nExtractionCliOptions

class I18nExtractionCliOptions extends CliOptions {}

constructor

constructor({
    i18nFormat,
    locale,
    outFile,
}: {
    i18nFormat?: string;
    locale?: string;
    outFile?: string;
});

property i18nFormat

i18nFormat: string;

property locale

locale: string;

property outFile

outFile: string;

class MetadataBundler

class MetadataBundler {}

constructor

constructor(root: string, importAs: string, host: MetadataBundlerHost);

method getMetadataBundle

getMetadataBundle: () => BundledModule;

method resolveModule

static resolveModule: (importName: string, from: string) => string;

class MetadataCollector

class MetadataCollector {}

Collect decorator metadata from a TypeScript module.

constructor

constructor(options?: CollectorOptions);

method getMetadata

getMetadata: (sourceFile: ts.SourceFile, strict?: boolean) => ModuleMetadata;

Returns a JSON.stringify friendly form describing the decorators of the exported classes from the source file that is expected to correspond to a module.

class MetadataWriterHost

class MetadataWriterHost extends DelegatingHost {}

constructor

constructor(
    delegate: ts.CompilerHost,
    ngOptions: NgOptions,
    emitAllFiles: boolean
);

property writeFile

writeFile: ts.WriteFileCallback;

class NgcCliOptions

class NgcCliOptions extends CliOptions {}

constructor

constructor({
    i18nFormat,
    i18nFile,
    locale,
    missingTranslation,
    basePath,
}: {
    i18nFormat?: string;
    i18nFile?: string;
    locale?: string;
    missingTranslation?: string;
    basePath?: string;
});

property i18nFile

i18nFile: string;

property i18nFormat

i18nFormat: string;

property locale

locale: string;

property missingTranslation

missingTranslation: string;

class UserError

class UserError extends Error {}

constructor

constructor(message: string);

property message

message: string;

property name

name: string;

property stack

stack: any;

method toString

toString: () => string;

Interfaces

interface AngularCompilerOptions

interface Options extends ts.CompilerOptions {}

property alwaysCompileGeneratedCode

alwaysCompileGeneratedCode?: boolean;

property annotateForClosureCompiler

annotateForClosureCompiler?: boolean;

property annotationsAs

annotationsAs?: 'decorators' | 'static fields';

property basePath

basePath?: string;

property debug

debug?: boolean;

Deprecated
since v4 this option has no effect anymore.

property enableLegacyTemplate

enableLegacyTemplate?: boolean;

property enableSummariesForJit

enableSummariesForJit?: boolean;

property flatModuleId

flatModuleId?: string;

property flatModuleOutFile

flatModuleOutFile?: string;

property genDir

genDir?: string;

property generateCodeForLibraries

generateCodeForLibraries?: boolean;

property preserveWhitespaces

preserveWhitespaces?: boolean;

property skipMetadataEmit

skipMetadataEmit?: boolean;

property skipTemplateCodegen

skipTemplateCodegen?: boolean;

property strictMetadataEmit

strictMetadataEmit?: boolean;

property trace

trace?: boolean;

interface BundledModule

interface BundledModule {}

property metadata

metadata: ModuleMetadata;

property privates

privates: BundlePrivateEntry[];

interface BundleEntries

interface BundleEntries {}

index signature

[name: string]: MetadataEntry;

interface BundlePrivateEntry

interface BundlePrivateEntry {}

property module

module: string;

property name

name: string;

property privateName

privateName: string;

interface ClassMetadata

interface ClassMetadata {}

property arity

arity?: number;

property decorators

decorators?: (MetadataSymbolicExpression | MetadataError)[];

property extends

extends?: MetadataSymbolicExpression | MetadataError;

property members

members?: MetadataMap;

property statics

statics?: {
    [name: string]: MetadataValue | FunctionMetadata;
};

interface CodegenExtension

interface CodegenExtension {}

call signature

(
    ngOptions: NgOptions,
    cliOptions: CliOptions,
    program: ts.Program,
    host: ts.CompilerHost
): Promise<string[]>;

Returns the generated file names.

interface ConstructorMetadata

interface ConstructorMetadata extends MethodMetadata {}

property parameters

parameters?: (MetadataSymbolicExpression | MetadataError | null)[];

interface FunctionMetadata

interface FunctionMetadata {}

property defaults

defaults?: MetadataValue[];

property parameters

parameters: string[];

property value

value: MetadataValue;

interface InterfaceMetadata

interface InterfaceMetadata {}

interface MemberMetadata

interface MemberMetadata {}

property decorators

decorators?: (MetadataSymbolicExpression | MetadataError)[];

interface MetadataArray

interface MetadataArray {}

index signature

[name: number]: MetadataValue;

interface MetadataBundlerHost

interface MetadataBundlerHost {}

method getMetadataFor

getMetadataFor: (moduleName: string) => ModuleMetadata;

interface MetadataError

interface MetadataError {}

property character

character?: number;

The number of utf8 code-units from the beginning of the file of the error.

property context

context?: {
    [name: string]: string;
};

Context information that can be used to generate a more descriptive error message. The content of the context is dependent on the error message.

property line

line?: number;

The line number of the error in the .ts file the metadata was created for.

property message

message: string;

This message should be short and relatively discriptive and should be fixed once it is created. If the reader doesn't recognize the message, it will display the message unmodified. If the reader recognizes the error message is it free to use substitute message the is more descriptive and/or localized.

property module

module?: string;

The module of the error (only used in bundled metadata)

interface MetadataGlobalReferenceExpression

interface MetadataGlobalReferenceExpression extends MetadataSymbolicExpression {}

property arguments

arguments?: MetadataValue[];

property name

name: string;

interface MetadataImportedDefaultReferenceExpression

interface MetadataImportedDefaultReferenceExpression
    extends MetadataSymbolicExpression {}

property arguments

arguments?: MetadataValue[];

property default

default: boolean;

property module

module: string;

interface MetadataImportedSymbolReferenceExpression

interface MetadataImportedSymbolReferenceExpression
    extends MetadataSymbolicExpression {}

property arguments

arguments?: MetadataValue[];

property module

module: string;

property name

name: string;

interface MetadataMap

interface MetadataMap {}

index signature

[name: string]: MemberMetadata[];

interface MetadataModuleReferenceExpression

interface MetadataModuleReferenceExpression extends MetadataSymbolicExpression {}

property module

module: string;

interface MetadataObject

interface MetadataObject {}

index signature

[name: string]: MetadataValue;

interface MetadataSymbolicBinaryExpression

interface MetadataSymbolicBinaryExpression extends MetadataSymbolicExpression {}

property left

left: MetadataValue;

property operator

operator:
    | '&&'
    | '||'
    | '|'
    | '^'
    | '&'
    | '=='
    | '!='
    | '==='
    | '!=='
    | '<'
    | '>'
    | '<='
    | '>='
    | 'instanceof'
    | 'in'
    | 'as'
    | '<<'
    | '>>'
    | '>>>'
    | '+'
    | '-'
    | '*'
    | '/'
    | '%'
    | '**';

property right

right: MetadataValue;

interface MetadataSymbolicCallExpression

interface MetadataSymbolicCallExpression extends MetadataSymbolicExpression {}

property arguments

arguments?: MetadataValue[];

property expression

expression: MetadataValue;

interface MetadataSymbolicExpression

interface MetadataSymbolicExpression {}

interface MetadataSymbolicIfExpression

interface MetadataSymbolicIfExpression extends MetadataSymbolicExpression {}

property condition

condition: MetadataValue;

property elseExpression

elseExpression: MetadataValue;

property thenExpression

thenExpression: MetadataValue;

interface MetadataSymbolicIndexExpression

interface MetadataSymbolicIndexExpression extends MetadataSymbolicExpression {}

property expression

expression: MetadataValue;

property index

index: MetadataValue;

interface MetadataSymbolicPrefixExpression

interface MetadataSymbolicPrefixExpression extends MetadataSymbolicExpression {}

property operand

operand: MetadataValue;

property operator

operator: '+' | '-' | '~' | '!';

interface MetadataSymbolicSelectExpression

interface MetadataSymbolicSelectExpression extends MetadataSymbolicExpression {}

property expression

expression: MetadataValue;

property name

name: string;

interface MetadataSymbolicSpreadExpression

interface MetadataSymbolicSpreadExpression extends MetadataSymbolicExpression {}

property expression

expression: MetadataValue;

interface MethodMetadata

interface MethodMetadata extends MemberMetadata {}

property parameterDecorators

parameterDecorators?: (MetadataSymbolicExpression | MetadataError)[][];

interface ModuleExportMetadata

interface ModuleExportMetadata {}

property export

export?: (
    | string
    | {
          name: string;
          as: string;
      }
)[];

property from

from: string;

interface ModuleMetadata

interface ModuleMetadata {}

property exports

exports?: ModuleExportMetadata[];

property importAs

importAs?: string;

property metadata

metadata: {
    [name: string]: MetadataEntry;
};

property origins

origins?: {
    [name: string]: string;
};

property version

version: number;

Type Aliases

type MetadataEntry

type MetadataEntry =
    | ClassMetadata
    | InterfaceMetadata
    | FunctionMetadata
    | MetadataValue;

type MetadataSymbolicReferenceExpression

type MetadataSymbolicReferenceExpression =
    | MetadataGlobalReferenceExpression
    | MetadataModuleReferenceExpression
    | MetadataImportedSymbolReferenceExpression
    | MetadataImportedDefaultReferenceExpression;

type MetadataValue

type MetadataValue =
    | string
    | number
    | boolean
    | MetadataObject
    | MetadataArray
    | MetadataSymbolicExpression
    | MetadataError;

Package Files (10)

Dependencies (1)

tsickle

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (1)

typescript

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@angular/tsc-wrapped.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@angular/tsc-wrapped)

HTML

<a href="https://www.jsdocs.io/package/@angular/tsc-wrapped"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 6036 ms.
Missing or incorrect documentation? Open an issue for this package.

@angular/tsc-wrapped

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable VERSION

Functions

function createBundleIndexHost

function isClassMetadata

function isConstructorMetadata

function isFunctionMetadata

function isInterfaceMetadata

function isMemberMetadata

function isMetadataError

function isMetadataGlobalReferenceExpression

function isMetadataImportDefaultReference

function isMetadataImportedSymbolReferenceExpression

function isMetadataModuleReferenceExpression

function isMetadataSymbolicBinaryExpression

function isMetadataSymbolicCallExpression

function isMetadataSymbolicExpression

function isMetadataSymbolicIfExpression

function isMetadataSymbolicIndexExpression

function isMetadataSymbolicPrefixExpression

function isMetadataSymbolicReferenceExpression

function isMetadataSymbolicSelectExpression

function isMetadataSymbolicSpreadExpression

function isMethodMetadata

function isModuleMetadata

function main

function privateEntriesToIndex

Classes

class CliOptions

property basePath

class CollectorOptions

property quotedNames

property verboseInvalidExpression

property version

class CompilerHostAdapter

method getMetadataFor

class I18nExtractionCliOptions

property i18nFormat

property locale

property outFile

class MetadataBundler

method getMetadataBundle

method resolveModule

class MetadataCollector

method getMetadata

class MetadataWriterHost

property writeFile

class NgcCliOptions

property i18nFile

property i18nFormat

property locale

property missingTranslation

class UserError

property message

property name

property stack

method toString

Interfaces

interface AngularCompilerOptions

property alwaysCompileGeneratedCode

property annotateForClosureCompiler

property annotationsAs

property basePath

property debug

Deprecated

property enableLegacyTemplate

property enableSummariesForJit

property flatModuleId

property flatModuleOutFile

property genDir

property generateCodeForLibraries