@angular-devkit/core

@angular-devkit/core

Version 12.0.3
Published 4 days ago
433 kB
6 dependencies
MIT license

Install

npm i @angular-devkit/core

yarn add @angular-devkit/core

pnpm add @angular-devkit/core

Overview

Angular DevKit - Core Utility Library

Index

Variables

variable NormalizedRoot

const NormalizedRoot: String & { __PRIVATE_DEVKIT_PATH: void };

The root of a normalized path. {Path}

variable NormalizedSep

const NormalizedSep: String & { __PRIVATE_DEVKIT_PATH: void };

The Separator for normalized path. {Path}

variable path

const path: TemplateTag<Path>;

Functions

function asPosixPath

asPosixPath: (path: Path) => PosixPath;

function asWindowsPath

asWindowsPath: (path: Path) => WindowsPath;

function basename

basename: (path: Path) => PathFragment;

Return the basename of the path, as a Path. See path.basename

function clean

clean: <T>(array: Array<T | undefined>) => Array<T>;

Deprecated
Since v12.0, unused by the Angular tooling

function deepCopy

deepCopy: <T extends unknown>(value: T) => T;

function dirname

dirname: (path: Path) => Path;

Return the dirname of the path, as a Path. See path.dirname

function extname

extname: (path: Path) => string;

function fragment

fragment: (path: string) => PathFragment;

function getSystemPath

getSystemPath: (path: Path) => string;

function isAbsolute

isAbsolute: (p: Path) => boolean;

Returns true if a path is absolute.

function isJsonArray

isJsonArray: (value: JsonValue) => value is JsonArray;

function isJsonObject

isJsonObject: (value: JsonValue) => value is JsonObject;

function isPromise

isPromise: (obj: any) => obj is Promise<any>;

Determine if the argument is shaped like a Promise

function join

join: (p1: Path, ...others: string[]) => Path;

Join multiple paths together, and normalize the result. Accepts strings that will be normalized as well (but the original must be a path).

function mapObject

mapObject: <T, V>(
    obj: { [k: string]: T },
    mapper: (k: string, v: T) => V
) => { [k: string]: V };

Deprecated
Since v12.0, unused by the Angular tooling

function noCacheNormalize

noCacheNormalize: (path: string) => Path;

The no cache version of the normalize() function. Used for benchmarking and testing.

function normalize

normalize: (path: string) => Path;

Normalize a string into a Path. This is the only mean to get a Path type from a string that represents a system path. This method cache the results as real world paths tend to be duplicated often. Normalization includes: - Windows backslashes \\ are replaced with /. - Windows drivers are replaced with /X/, where X is the drive letter. - Absolute paths starts with /. - Multiple / are replaced by a single one. - Path segments . are removed. - Path segments .. are resolved. - If a path is absolute, having a .. at the start is invalid (and will throw).
Parameter path
The path to be normalized.

function parseJson

parseJson: (
    input: string,
    mode?: JsonParseMode,
    options?: ParseJsonOptions
) => JsonValue;

Parse a JSON string into its value. This discards the AST and only returns the value itself.
If a path option is pass, it also absorbs JSON parsing errors and return a new error with the path in it. Useful for showing errors when parsing from a file.
Parameter input
The string to parse.
Parameter mode
The mode to parse the input with. .
Parameter options
Additional optinos for parsing.
Returns
{JsonValue} The value represented by the JSON string.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

function parseJsonAst

parseJsonAst: (input: string, mode?: JsonParseMode) => JsonAstNode;

Parse the JSON string and return its AST. The AST may be losing data (end comments are discarded for example, and space characters are not represented in the AST), but all values will have a single node in the AST (a 1-to-1 mapping).
Parameter input
The string to use.
Parameter mode
The mode to parse the input with. .
Returns
{JsonAstNode} The root node of the value of the AST.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

function relative

relative: (from: Path, to: Path) => Path;

Returns a path such that join(from, relative(from, to)) == to. Both paths must be absolute, otherwise it does not make much sense.

function resetNormalizeCache

resetNormalizeCache: () => void;

Reset the cache. This is only useful for testing.

function resolve

resolve: (p1: Path, p2: Path) => Path;

Returns a Path that is the resolution of p2, from p1. If p2 is absolute, it will return p2, otherwise will join both p1 and p2.

function split

split: (path: Path) => PathFragment[];

Split a path into multiple path fragments. Each fragments except the last one will end with a path separator.
Parameter path
The path to split.
Returns
{Path[]} An array of path fragments.

function template

template: <T>(
    content: string,
    options?: TemplateOptions
) => (input: T) => string;

An equivalent of EJS templates, which is based on John Resig's tmpl implementation (http://ejohn.org/blog/javascript-micro-templating/) and Laura Doktorova's doT.js (https://github.com/olado/doT).
This version differs from lodash by removing support from ES6 quasi-literals, and making the code slightly simpler to follow. It also does not depend on any third party, which is nice.
Finally, it supports SourceMap, if you ever need to debug, which is super nice.
Parameter content
The template content.
Parameter options
Optional Options. See TemplateOptions for more description. {(input: T) => string} A function that accept an input object and returns the content of the template with the input applied.

function templateParser

templateParser: (sourceText: string, fileName: string) => TemplateAst;

Given a source text (and a fileName), returns a TemplateAst.

Classes

class BaseException

class BaseException extends Error {}

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

constructor

constructor(message?: string);

class CircularDependencyFoundException

class CircularDependencyFoundException extends BaseException {}

constructor

constructor();

class ContentHasMutatedException

class ContentHasMutatedException extends BaseException {}

constructor

constructor(path: string);

class DependencyNotFoundException

class DependencyNotFoundException extends BaseException {}

constructor

constructor();

class FileAlreadyExistException

class FileAlreadyExistException extends BaseException {}

constructor

constructor(path: string);

class FileDoesNotExistException

class FileDoesNotExistException extends BaseException {}

constructor

constructor(path: string);

class InvalidJsonCharacterException

class InvalidJsonCharacterException extends JsonException {}

A character was invalid in this context.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

constructor

constructor(context: JsonParserContext);

property character

character: number;

property invalidChar

invalidChar: string;

property line

line: number;

property offset

offset: number;

class InvalidPathException

class InvalidPathException extends BaseException {}

constructor

constructor(path: string);

class InvalidUpdateRecordException

class InvalidUpdateRecordException extends BaseException {}

constructor

constructor();

class JsonException

class JsonException extends BaseException {}

class MergeConflictException

class MergeConflictException extends BaseException {}

constructor

constructor(path: string);

class PartiallyOrderedSet

class PartiallyOrderedSet<T> implements Set<T> {}

property [Symbol.toStringTag]

readonly [Symbol.toStringTag]: string;

property size

readonly size: number;

method [Symbol.iterator]

[Symbol.iterator]: () => Generator<T, void, unknown>;

method add

add: (item: T, deps?: Set<T> | T[]) => this;

method clear

clear: () => void;

method delete

delete: (item: T) => boolean;

method entries

entries: () => IterableIterator<[T, T]>;

Returns an iterable of [v,v] pairs for every value v in the set.

method forEach

forEach: (
    callbackfn: (value: T, value2: T, set: PartiallyOrderedSet<T>) => void,
    thisArg?: any
) => void;

method has

has: (item: T) => boolean;

method keys

keys: () => IterableIterator<T>;

Despite its name, returns an iterable of the values in the set,

method values

values: () => IterableIterator<T>;

Returns an iterable of values in the set.

class PathCannotBeFragmentException

class PathCannotBeFragmentException extends BaseException {}

constructor

constructor(path: string);

class PathIsDirectoryException

class PathIsDirectoryException extends BaseException {}

constructor

constructor(path: string);

class PathIsFileException

class PathIsFileException extends BaseException {}

constructor

constructor(path: string);

class PathMustBeAbsoluteException

class PathMustBeAbsoluteException extends BaseException {}

constructor

constructor(path: string);

class PathSpecificJsonException

class PathSpecificJsonException extends JsonException {}

An error happened within a file.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

constructor

constructor(path: string, exception: JsonException);

property exception

exception: JsonException;

property path

path: string;

class PriorityQueue

class PriorityQueue<T> {}

Naive priority queue; not intended for large datasets

constructor

constructor(_comparator: (x: T, y: T) => number);

property size

readonly size: number;

method clear

clear: () => void;

method peek

peek: () => T | undefined;

method pop

pop: () => T | undefined;

method push

push: (item: T) => void;

method toArray

toArray: () => Array<T>;

class UnexpectedEndOfInputException

class UnexpectedEndOfInputException extends JsonException {}

More input was expected, but we reached the end of the stream.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

constructor

constructor(_context: JsonParserContext);

class UnimplementedException

class UnimplementedException extends BaseException {}

constructor

constructor();

class UnknownException

class UnknownException extends BaseException {}

constructor

constructor(message: string);

class UnsupportedPlatformException

class UnsupportedPlatformException extends BaseException {}

constructor

constructor();

Interfaces

interface DeepReadonlyArray

interface DeepReadonlyArray<T> extends Array<DeepReadonly<T>> {}

interface JsonArray

interface JsonArray extends Array<JsonValue> {}

interface JsonAstArray

interface JsonAstArray extends JsonAstNodeBase {}

property elements

readonly elements: JsonAstNode[];

property kind

readonly kind: 'array';

property value

readonly value: JsonArray;

interface JsonAstComment

interface JsonAstComment extends JsonAstNodeBase {}

property content

readonly content: string;

property kind

readonly kind: 'comment';

interface JsonAstConstantFalse

interface JsonAstConstantFalse extends JsonAstNodeBase {}

property kind

readonly kind: 'false';

property value

readonly value: false;

interface JsonAstConstantNull

interface JsonAstConstantNull extends JsonAstNodeBase {}

property kind

readonly kind: 'null';

property value

readonly value: null;

interface JsonAstConstantTrue

interface JsonAstConstantTrue extends JsonAstNodeBase {}

property kind

readonly kind: 'true';

property value

readonly value: true;

interface JsonAstIdentifier

interface JsonAstIdentifier extends JsonAstNodeBase {}

property kind

readonly kind: 'identifier';

property value

readonly value: string;

interface JsonAstKeyValue

interface JsonAstKeyValue extends JsonAstNodeBase {}

property key

readonly key: JsonAstString | JsonAstIdentifier;

property kind

readonly kind: 'keyvalue';

property value

readonly value: JsonAstNode;

interface JsonAstMultilineComment

interface JsonAstMultilineComment extends JsonAstNodeBase {}

property content

readonly content: string;

property kind

readonly kind: 'multicomment';

interface JsonAstNodeBase

interface JsonAstNodeBase {}

property comments

readonly comments?: (JsonAstComment | JsonAstMultilineComment)[];

property end

readonly end: Position;

property start

readonly start: Position;

property text

readonly text: string;

interface JsonAstNumber

interface JsonAstNumber extends JsonAstNodeBase {}

property kind

readonly kind: 'number';

property value

readonly value: number;

interface JsonAstObject

interface JsonAstObject extends JsonAstNodeBase {}

property kind

readonly kind: 'object';

property properties

readonly properties: JsonAstKeyValue[];

property value

readonly value: JsonObject;

interface JsonAstString

interface JsonAstString extends JsonAstNodeBase {}

property kind

readonly kind: 'string';

property value

readonly value: string;

interface JsonObject

interface JsonObject {}

index signature

[prop: string]: JsonValue;

interface JsonParserContext

interface JsonParserContext {}

Context passed around the parser with information about where we currently are in the parse.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

property mode

readonly mode: JsonParseMode;

property original

readonly original: string;

property position

position: Position;

property previous

previous: Position;

interface ParseJsonOptions

interface ParseJsonOptions {}

Options for the parseJson() function.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

property path

path?: string;

If omitted, will only emit errors related to the content of the JSON. If specified, any JSON errors will also include the path of the file that caused the error.

interface Position

interface Position {}

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

property character

readonly character: number;

property line

readonly line: number;

property offset

readonly offset: number;

interface TemplateAst

interface TemplateAst {}

A simple AST for templates. There's only one level of AST nodes, but it's still useful to have the information you're looking for.

property children

children: TemplateAstNode[];

property content

content: string;

property fileName

fileName: string;

interface TemplateAstBase

interface TemplateAstBase {}

The base, which contains positions.

property end

end: Position;

property start

start: Position;

interface TemplateAstComment

interface TemplateAstComment extends TemplateAstBase {}

A comment node.

property kind

kind: 'comment';

property text

text: string;

interface TemplateAstContent

interface TemplateAstContent extends TemplateAstBase {}

A static content node.

property content

content: string;

property kind

kind: 'content';

interface TemplateAstEscape

interface TemplateAstEscape extends TemplateAstBase {}

An escape node, which is the code between <%- ... %>.

property expression

expression: string;

property kind

kind: 'escape';

interface TemplateAstEvaluate

interface TemplateAstEvaluate extends TemplateAstBase {}

An evaluate node, which is the code between <% ... %>.

property expression

expression: string;

property kind

kind: 'evaluate';

interface TemplateAstInterpolate

interface TemplateAstInterpolate extends TemplateAstBase {}

An interpolation node, which is the code between <%= ... %>.

property expression

expression: string;

property kind

kind: 'interpolate';

interface TemplateOptions

interface TemplateOptions {}

property fileName

fileName?: string;

property module

module?:
    | boolean
    | {
          exports: {};
      };

property sourceMap

sourceMap?: boolean;

property sourceRoot

sourceRoot?: string;

property sourceURL

sourceURL?: string;

Enums

enum JsonParseMode

enum JsonParseMode {
    Strict = 0,
    CommentsAllowed = 1,
    SingleQuotesAllowed = 2,
    IdentifierKeyNamesAllowed = 4,
    TrailingCommasAllowed = 8,
    HexadecimalNumberAllowed = 16,
    MultiLineStringAllowed = 32,
    LaxNumberParsingAllowed = 64,
    NumberConstantsAllowed = 128,
    Default = 0,
    Loose = 255,
    Json = 0,
    Json5 = 255,
}

The Parse mode used for parsing the JSON string.

member CommentsAllowed

CommentsAllowed = 1

member Default

Default = 0

member HexadecimalNumberAllowed

HexadecimalNumberAllowed = 16

member IdentifierKeyNamesAllowed

IdentifierKeyNamesAllowed = 4

member Json

Json = 0

member Json5

Json5 = 255

member LaxNumberParsingAllowed

LaxNumberParsingAllowed = 64

member Loose

Loose = 255

member MultiLineStringAllowed

MultiLineStringAllowed = 32

member NumberConstantsAllowed

NumberConstantsAllowed = 128

member SingleQuotesAllowed

SingleQuotesAllowed = 2

member Strict

Strict = 0

member TrailingCommasAllowed

TrailingCommasAllowed = 8

Type Aliases

type DeepReadonly

type DeepReadonly<T> = T extends (infer R)[]
    ? DeepReadonlyArray<R>
    : T extends Function
    ? T
    : T extends object
    ? DeepReadonlyObject<T>
    : T;

type DeepReadonlyObject

type DeepReadonlyObject<T> = {
    readonly [P in keyof T]: DeepReadonly<T[P]>;
};

type JsonAstNode

type JsonAstNode =
    | JsonAstNumber
    | JsonAstString
    | JsonAstIdentifier
    | JsonAstArray
    | JsonAstObject
    | JsonAstConstantFalse
    | JsonAstConstantNull
    | JsonAstConstantTrue;

type JsonValue

type JsonValue = JsonAstNode['value'];

type Path

type Path = string & {
    __PRIVATE_DEVKIT_PATH: void;
};

A Path recognized by most methods in the DevKit.

type PathFragment

type PathFragment = Path & {
    __PRIVATE_DEVKIT_PATH_FRAGMENT: void;
};

A Path fragment (file or directory name) recognized by most methods in the DevKit.

type PosixPath

type PosixPath = string & {
    __PRIVATE_DEVKIT_POSIX_PATH: void;
};

type Readwrite

type Readwrite<T> = {
    -readonly [P in keyof T]: T[P];
};

type TemplateAstNode

type TemplateAstNode =
    | TemplateAstContent
    | TemplateAstEvaluate
    | TemplateAstComment
    | TemplateAstEscape
    | TemplateAstInterpolate;

type WindowsPath

type WindowsPath = string & {
    __PRIVATE_DEVKIT_WINDOWS_PATH: void;
};

Namespaces

namespace analytics

module 'src/analytics/index.d.ts' {}

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

variable NgCliAnalyticsDimensionsFlagInfo

const NgCliAnalyticsDimensionsFlagInfo: { [name: string]: [string, string] };

variable NgCliAnalyticsMetricsFlagInfo

const NgCliAnalyticsMetricsFlagInfo: { [name: string]: [string, string] };

class AnalyticsReporter

class AnalyticsReporter {}

constructor

constructor(_analytics: Analytics);

method report

report: (report: AnalyticsReport) => void;

class ForwardingAnalytics

class ForwardingAnalytics implements Analytics {}

A class that follows the Analytics interface and forwards analytic reports (JavaScript objects). AnalyticsReporter is the counterpart which takes analytic reports and report them to another Analytics interface.

constructor

constructor(_fn: AnalyticsForwarderFn);

method event

event: (category: string, action: string, options?: EventOptions) => void;

method flush

flush: () => Promise<void>;

method pageview

pageview: (path: string, options?: PageviewOptions) => void;

method screenview

screenview: (
    screenName: string,
    appName: string,
    options?: ScreenviewOptions
) => void;

method timing

timing: (
    category: string,
    variable: string,
    time: string | number,
    options?: TimingOptions
) => void;

class LoggingAnalytics

class LoggingAnalytics implements Analytics {}

Analytics implementation that logs analytics events to a logger. This should be used for debugging mainly.

constructor

constructor(_logger: Logger);

method event

event: (category: string, action: string, options?: EventOptions) => void;

method flush

flush: () => Promise<void>;

method pageview

pageview: (path: string, options?: PageviewOptions) => void;

method screenview

screenview: (
    screenName: string,
    appName: string,
    options?: ScreenviewOptions
) => void;

method timing

timing: (
    category: string,
    variable: string,
    time: string | number,
    options?: TimingOptions
) => void;

class MultiAnalytics

class MultiAnalytics implements Analytics {}

Analytics implementation that reports to multiple analytics backend.

constructor

constructor(_backends?: Analytics[]);

method event

event: (category: string, action: string, options?: EventOptions) => void;

method flush

flush: () => Promise<void>;

method pageview

pageview: (path: string, options?: PageviewOptions) => void;

method push

push: (...backend: Analytics[]) => void;

method screenview

screenview: (
    screenName: string,
    appName: string,
    options?: ScreenviewOptions
) => void;

method timing

timing: (
    category: string,
    variable: string,
    time: string | number,
    options?: TimingOptions
) => void;

class NoopAnalytics

class NoopAnalytics implements Analytics {}

Analytics implementation that does nothing.

method event

event: () => void;

method flush

flush: () => Promise<void>;

method pageview

pageview: () => void;

method screenview

screenview: () => void;

method timing

timing: () => void;

interface Analytics

interface Analytics {}

Interface for managing analytics. This is highly platform dependent, and mostly matches Google Analytics. The reason the interface is here is to remove the dependency to an implementation from most other places.
The methods exported from this interface more or less match those needed by us in the universal analytics package, see https://unpkg.com/@types/universal-analytics@0.4.2/index.d.ts for typings. We mostly named arguments to make it easier to follow, but didn't change or add any semantics to those methods. They're mapping GA and u-a one for one.
The Angular CLI (or any other kind of backend) should forward it to some compatible backend.

method event

event: (category: string, action: string, options?: EventOptions) => void;

method flush

flush: () => Promise<void>;

method pageview

pageview: (path: string, options?: PageviewOptions) => void;

method screenview

screenview: (
    screenName: string,
    appName: string,
    options?: ScreenviewOptions
) => void;

method timing

timing: (
    category: string,
    variable: string,
    time: string | number,
    options?: TimingOptions
) => void;

interface AnalyticsReportBase

interface AnalyticsReportBase extends JsonObject {}

property kind

kind: AnalyticsReportKind;

interface AnalyticsReportEvent

interface AnalyticsReportEvent extends AnalyticsReportBase {}

property action

action: string;

property category

category: string;

property kind

kind: AnalyticsReportKind.Event;

property options

options: JsonObject & EventOptions;

interface AnalyticsReportPageview

interface AnalyticsReportPageview extends AnalyticsReportBase {}

property kind

kind: AnalyticsReportKind.Pageview;

property options

options: JsonObject & PageviewOptions;

property path

path: string;

interface AnalyticsReportScreenview

interface AnalyticsReportScreenview extends AnalyticsReportBase {}

property appName

appName: string;

property kind

kind: AnalyticsReportKind.Screenview;

property options

options: JsonObject & ScreenviewOptions;

property screenName

screenName: string;

interface AnalyticsReportTiming

interface AnalyticsReportTiming extends AnalyticsReportBase {}

property category

category: string;

property kind

kind: AnalyticsReportKind.Timing;

property options

options: JsonObject & TimingOptions;

property time

time: string | number;

property variable

variable: string;

interface CustomDimensionsAndMetricsOptions

interface CustomDimensionsAndMetricsOptions {}

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

property dimensions

dimensions?: (boolean | number | string)[];

property metrics

metrics?: (boolean | number | string)[];

interface EventOptions

interface EventOptions extends CustomDimensionsAndMetricsOptions {}

property label

label?: string;

property value

value?: string;

interface PageviewOptions

interface PageviewOptions extends CustomDimensionsAndMetricsOptions {}

property hostname

hostname?: string;

property title

title?: string;

interface ScreenviewOptions

interface ScreenviewOptions extends CustomDimensionsAndMetricsOptions {}

property appId

appId?: string;

property appInstallerId

appInstallerId?: string;

property appVersion

appVersion?: string;

interface TimingOptions

interface TimingOptions extends CustomDimensionsAndMetricsOptions {}

property label

label?: string;

enum AnalyticsReportKind

enum AnalyticsReportKind {
    Event = 'event',
    Screenview = 'screenview',
    Pageview = 'pageview',
    Timing = 'timing',
}

member Event

Event = 'event'

member Pageview

Pageview = 'pageview'

member Screenview

Screenview = 'screenview'

member Timing

Timing = 'timing'

enum NgCliAnalyticsDimensions

enum NgCliAnalyticsDimensions {
    CpuCount = 1,
    CpuSpeed = 2,
    RamInGigabytes = 3,
    NodeVersion = 4,
    NgAddCollection = 6,
    NgIvyEnabled = 8,
    BuildErrors = 20,
}

MAKE SURE TO KEEP THIS IN SYNC WITH THE TABLE AND CONTENT IN /docs/design/analytics.md. WE LIST THOSE DIMENSIONS (AND MORE).
These cannot be in their respective schema.json file because we either change the type (e.g. --buildEventLog is string, but we want to know the usage of it, not its value), or some validation needs to be done (we cannot record ng add --collection if it's not marked as allowed).

member BuildErrors

BuildErrors = 20

member CpuCount

CpuCount = 1

member CpuSpeed

CpuSpeed = 2

member NgAddCollection

NgAddCollection = 6

member NgIvyEnabled

NgIvyEnabled = 8

member NodeVersion

NodeVersion = 4

member RamInGigabytes

RamInGigabytes = 3

enum NgCliAnalyticsMetrics

enum NgCliAnalyticsMetrics {
    NgComponentCount = 1,
    UNUSED_2 = 2,
    UNUSED_3 = 3,
    UNUSED_4 = 4,
    BuildTime = 5,
    NgOnInitCount = 6,
    InitialChunkSize = 7,
    TotalChunkCount = 8,
    TotalChunkSize = 9,
    LazyChunkCount = 10,
    LazyChunkSize = 11,
    AssetCount = 12,
    AssetSize = 13,
    PolyfillSize = 14,
    CssSize = 15,
}

member AssetCount

AssetCount = 12

member AssetSize

AssetSize = 13

member BuildTime

BuildTime = 5

member CssSize

CssSize = 15

member InitialChunkSize

InitialChunkSize = 7

member LazyChunkCount

LazyChunkCount = 10

member LazyChunkSize

LazyChunkSize = 11

member NgComponentCount

NgComponentCount = 1

member NgOnInitCount

NgOnInitCount = 6

member PolyfillSize

PolyfillSize = 14

member TotalChunkCount

TotalChunkCount = 8

member TotalChunkSize

TotalChunkSize = 9

member UNUSED_2

UNUSED_2 = 2

member UNUSED_3

UNUSED_3 = 3

member UNUSED_4

UNUSED_4 = 4

type AnalyticsForwarderFn

type AnalyticsForwarderFn = (report: JsonObject & AnalyticsReport) => void;

A function that can forward analytics along some stream. AnalyticsReport is already a JsonObject descendant, but we force it here so the user knows it's safe to serialize.

type AnalyticsReport

type AnalyticsReport =
    | AnalyticsReportEvent
    | AnalyticsReportScreenview
    | AnalyticsReportPageview
    | AnalyticsReportTiming;

namespace experimental

module 'src/experimental.d.ts' {}

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

namespace jobs

module 'src/experimental/jobs/index.d.ts' {}

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

function createDispatcher

createDispatcher: <
    A extends string | number | boolean | JsonObject | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray
>(
    options?: Partial<Readwrite<JobDescription>>
) => JobDispatcher<A, I, O>;

OnReady a dispatcher that can dispatch to a sub job, depending on conditions.
Parameter options

function createJobFactory

createJobFactory: <
    A extends string | number | boolean | JsonObject | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray
>(
    loader: () => Promise<JobHandler<A, I, O>>,
    options?: Partial<JobDescription>
) => JobHandler<A, I, O>;

Lazily create a job using a function.
Parameter loader
A factory function that returns a promise/observable of a JobHandler.
Parameter options
Same options as createJob.

function createJobHandler

createJobHandler: <
    A extends string | number | boolean | JsonObject | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray
>(
    fn: SimpleJobHandlerFn<A, I, O>,
    options?: Partial<JobDescription>
) => JobHandler<A, I, O>;

Make a simple job handler that sets start and end from a function that's synchronous.
Parameter fn
The function to create a handler for.
Parameter options
An optional set of properties to set on the handler. Some fields might be required by registry or schedulers.

function createLoggerJob

createLoggerJob: <
    A extends string | number | boolean | JsonObject | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray
>(
    job: JobHandler<A, I, O>,
    logger: LoggerApi
) => JobHandler<A, I, O>;

Creates a job that logs out input/output messages of another Job. The messages are still propagated to the other job.

function isJobHandler

isJobHandler: <
    A extends string | number | boolean | JsonObject | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray
>(
    value: unknown
) => value is JobHandler<A, I, O>;

class ChannelAlreadyExistException

class ChannelAlreadyExistException extends BaseException {}

constructor

constructor(name: string);

class FallbackRegistry

class FallbackRegistry<
    MinimumArgumentValueT extends JsonValue = JsonValue,
    MinimumInputValueT extends JsonValue = JsonValue,
    MinimumOutputValueT extends JsonValue = JsonValue
> implements
        Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {}

A simple job registry that keep a map of JobName => JobHandler internally.

constructor

constructor(
    _fallbacks?: Registry<
        MinimumArgumentValueT,
        MinimumInputValueT,
        MinimumOutputValueT
    >[]
);

method addFallback

addFallback: (registry: Registry) => void;

method get

get: <
    A extends MinimumArgumentValueT = MinimumArgumentValueT,
    I extends MinimumInputValueT = MinimumInputValueT,
    O extends MinimumOutputValueT = MinimumOutputValueT
>(
    name: JobName
) => any;

class JobArgumentSchemaValidationError

class JobArgumentSchemaValidationError extends schema.SchemaValidationException {}

constructor

constructor(errors?: any[]);

class JobDoesNotExistException

class JobDoesNotExistException extends BaseException {}

constructor

constructor(name: string);

class JobInboundMessageSchemaValidationError

class JobInboundMessageSchemaValidationError extends schema.SchemaValidationException {}

constructor

constructor(errors?: any[]);

class JobNameAlreadyRegisteredException

class JobNameAlreadyRegisteredException extends BaseException {}

constructor

constructor(name: string);

class JobOutputSchemaValidationError

class JobOutputSchemaValidationError extends schema.SchemaValidationException {}

constructor

constructor(errors?: any[]);

class SimpleJobRegistry

class SimpleJobRegistry<
    MinimumArgumentValueT extends JsonValue = JsonValue,
    MinimumInputValueT extends JsonValue = JsonValue,
    MinimumOutputValueT extends JsonValue = JsonValue
> implements
        Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {}

A simple job registry that keep a map of JobName => JobHandler internally.

method get

get: <
    A extends MinimumArgumentValueT = MinimumArgumentValueT,
    I extends MinimumInputValueT = MinimumInputValueT,
    O extends MinimumOutputValueT = MinimumOutputValueT
>(
    name: JobName
) => any;

method getJobNames

getJobNames: () => JobName[];

Returns the job names of all jobs.

method register

register: {
    <
        A extends MinimumArgumentValueT,
        I extends MinimumInputValueT,
        O extends MinimumOutputValueT
    >(
        name: JobName,
        handler: JobHandler<A, I, O>,
        options?: RegisterJobOptions
    ): void;
    <
        ArgumentT extends string | number | boolean | JsonObject | JsonArray,
        InputT extends string | number | boolean | JsonObject | JsonArray,
        OutputT extends string | number | boolean | JsonObject | JsonArray
    >(
        handler: JobHandler<ArgumentT, InputT, OutputT>,
        options?: RegisterJobOptions & { name: string }
    ): void;
};

Register a job handler. The name must be unique.
Parameter name
The name of the job.
Parameter handler
The function that will be called for the job.
Parameter options
An optional list of options to override the handler.
Register a job handler. The name must be unique.
Parameter handler
The function that will be called for the job.
Parameter options
An optional list of options to override the handler.

class SimpleScheduler

class SimpleScheduler<
    MinimumArgumentT extends JsonValue = JsonValue,
    MinimumInputT extends JsonValue = JsonValue,
    MinimumOutputT extends JsonValue = JsonValue
> implements Scheduler<MinimumArgumentT, MinimumInputT, MinimumOutputT> {}

Simple scheduler. Should be the base of all registries and schedulers.

constructor

constructor(
    _jobRegistry: Registry<MinimumArgumentT, MinimumInputT, MinimumOutputT>,
    _schemaRegistry?: schema.SchemaRegistry
);

method getDescription

getDescription: (name: JobName) => any;

Get a job description for a named job.
Parameter name
The name of the job.
Returns
A description, or null if the job is not registered.

method has

has: (name: JobName) => any;

Returns true if the job name has been registered.
Parameter name
The name of the job.
Returns
True if the job exists, false otherwise.

method pause

pause: () => () => void;

Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be used to resume execution. If multiple pause() were called, all their resume functions must be called before the Scheduler actually starts new jobs. Additional calls to the same resume function will have no effect.
Jobs already running are NOT paused. This is pausing the scheduler only.

method schedule

schedule: <
    A extends MinimumArgumentT,
    I extends MinimumInputT,
    O extends MinimumOutputT
>(
    name: JobName,
    argument: A,
    options?: ScheduleJobOptions
) => Job<A, I, O>;

Schedule a job to be run, using its name.
Parameter name
The name of job to be run.
Parameter argument
The argument to send to the job when starting it.
Parameter options
Scheduling options.
Returns
The Job being run.

interface Job

interface Job<
    ArgumentT extends JsonValue = JsonValue,
    InputT extends JsonValue = JsonValue,
    OutputT extends JsonValue = JsonValue
> {}

A Job instance, returned from scheduling a job. A Job instance is _not_ serializable.

property argument

readonly argument: ArgumentT;

Argument sent when scheduling the job. This is a copy of the argument.

property description

readonly description: Observable<JobDescription>;

Description of the job. Resolving the job's description can be done asynchronously, so this is an observable that will resolve when it's ready.

property inboundBus

readonly inboundBus: Observer<JobInboundMessage<InputT>>;

The JobInboundMessage messages TO the job.

property input

readonly input: Observer<InputT>;

The input to the job. This goes through the input channel as messages.

property outboundBus

readonly outboundBus: Observable<JobOutboundMessage<OutputT>>;

The JobOutboundMessage FROM the job.

property output

readonly output: Observable<OutputT>;

Outputs of this job.

property state

readonly state: JobState;

The current state of the job.

method getChannel

getChannel: <T extends string | number | boolean | JsonObject | JsonArray>(
    name: string,
    schema?: schema.JsonSchema
) => any;

Get a channel that validates against the schema. Messages will be filtered by the schema.
Parameter name
The name of the channel.
Parameter schema
A schema to use to validate messages.

method ping

ping: () => any;

Pings the job and wait for the resulting Pong before completing.

method stop

stop: () => void;

Stops the job from running. This is different than unsubscribing from the output as in it sends the JobInboundMessageKind.Stop raw input to the job.

interface JobDescription

interface JobDescription extends JsonObject {}

Metadata associated with a job.

property argument

readonly argument: DeepReadonly<schema.JsonSchema>;

property input

readonly input: DeepReadonly<schema.JsonSchema>;

property name

readonly name: JobName;

property output

readonly output: DeepReadonly<schema.JsonSchema>;

interface JobDispatcher

interface JobDispatcher<
    A extends JsonValue,
    I extends JsonValue,
    O extends JsonValue
> extends JobHandler<A, I, O> {}

A JobDispatcher can be used to dispatch between multiple jobs.

method addConditionalJob

addConditionalJob: (predicate: (args: A) => boolean, name: string) => void;

Add a conditional job that will be selected if the input fits a predicate.
Parameter predicate
Parameter name

method setDefaultJob

setDefaultJob: (
    name: JobName | null | JobHandler<JsonValue, JsonValue, JsonValue>
) => void;

Set the default job if all conditionals failed.
Parameter name
The default name if all conditions are false.

interface JobHandler

interface JobHandler<
    ArgT extends JsonValue,
    InputT extends JsonValue,
    OutputT extends JsonValue
> {}

The job handler function, which is a method that's executed for the job.

property jobDescription

jobDescription: Partial<JobDescription>;

call signature

(argument: ArgT, context: JobHandlerContext<ArgT, InputT, OutputT>): Observable<
    JobOutboundMessage<OutputT>
>;

interface JobHandlerContext

interface JobHandlerContext<
    MinimumArgumentValueT extends JsonValue = JsonValue,
    MinimumInputValueT extends JsonValue = JsonValue,
    MinimumOutputValueT extends JsonValue = JsonValue
> {}

The context in which the job is run.

property dependencies

readonly dependencies: Job<JsonValue, JsonValue, JsonValue>[];

property description

readonly description: JobDescription;

property inboundBus

readonly inboundBus: Observable<JobInboundMessage<MinimumInputValueT>>;

property scheduler

readonly scheduler: Scheduler<JsonValue, JsonValue, JsonValue>;

interface JobInboundMessageBase

interface JobInboundMessageBase extends JsonObject {}

Base interface for the all job inbound messages.

property kind

readonly kind: JobInboundMessageKind;

The kind of message this is.

interface JobInboundMessageInput

interface JobInboundMessageInput<InputT extends JsonValue>
    extends JobInboundMessageBase {}

A Job wants to send a message to a channel. This can be marshaled, and the Job object has helpers to transform this into an observable. The context also can create RxJS subjects that marshall messages through a channel.

property kind

readonly kind: JobInboundMessageKind.Input;

property value

readonly value: InputT;

The input being sent to the job.

interface JobInboundMessagePing

interface JobInboundMessagePing extends JobInboundMessageBase {}

A ping to the job. The job should reply with a pong as soon as possible.

property id

readonly id: number;

An ID that should be returned in the corresponding Pong.

property kind

readonly kind: JobInboundMessageKind.Ping;

interface JobInboundMessageStop

interface JobInboundMessageStop extends JobInboundMessageBase {}

Stop the job. This is handled by the job itself and jobs might not handle it. It will also unsubscribe from the Observable<>. This is equivalent to SIGTERM.

property kind

readonly kind: JobInboundMessageKind.Stop;

interface JobOutboundMessageBase

interface JobOutboundMessageBase {}

Base interface for the all job messages.

property description

readonly description: JobDescription;

The job description.

property kind

readonly kind: JobOutboundMessageKind;

The kind of message this is.

interface JobOutboundMessageChannelBase

interface JobOutboundMessageChannelBase extends JobOutboundMessageBase {}

Base interface for all job message related to channels.

property name

readonly name: string;

The name of the channel.

interface JobOutboundMessageChannelComplete

interface JobOutboundMessageChannelComplete extends JobOutboundMessageChannelBase {}

A job wants to close the channel, as completed. This is done automatically when the job ends, or can be done from the job to close it. A closed channel might be reopened, but the user need to recall getChannel().

property kind

readonly kind: JobOutboundMessageKind.ChannelComplete;

interface JobOutboundMessageChannelCreate

interface JobOutboundMessageChannelCreate extends JobOutboundMessageChannelBase {}

A job wants to create a new channel.

property kind

readonly kind: JobOutboundMessageKind.ChannelCreate;

interface JobOutboundMessageChannelError

interface JobOutboundMessageChannelError extends JobOutboundMessageChannelBase {}

A job wants to send an error to one of its channel. This is the equivalent of throwing through an Observable. The side channel will not receive any more messages after this, and will not complete.

property error

readonly error: JsonValue;

The error message being sent to the channel.

property kind

readonly kind: JobOutboundMessageKind.ChannelError;

interface JobOutboundMessageChannelMessage

interface JobOutboundMessageChannelMessage extends JobOutboundMessageChannelBase {}

A job wants to send a message to a channel. This can be marshaled, and the Job object has helpers to transform this into an observable. The context also can create RxJS subjects that marshall messages through a channel.

property kind

readonly kind: JobOutboundMessageKind.ChannelMessage;

property message

readonly message: JsonValue;

The message being sent to the channel.

interface JobOutboundMessageEnd

interface JobOutboundMessageEnd extends JobOutboundMessageBase {}

OnEnd of the job run.

property kind

readonly kind: JobOutboundMessageKind.End;

interface JobOutboundMessageOnReady

interface JobOutboundMessageOnReady extends JobOutboundMessageBase {}

The job has been created and will validate its input.

property kind

readonly kind: JobOutboundMessageKind.OnReady;

interface JobOutboundMessageOutput

interface JobOutboundMessageOutput<OutputT extends JsonValue>
    extends JobOutboundMessageBase {}

An output value is available.

property kind

readonly kind: JobOutboundMessageKind.Output;

property value

readonly value: OutputT;

The message being outputted from the job.

interface JobOutboundMessagePong

interface JobOutboundMessagePong extends JobOutboundMessageBase {}

A pong response from a ping input. The id is the same as the one passed in.

property id

readonly id: number;

The ID that was passed in the Ping messages.

property kind

readonly kind: JobOutboundMessageKind.Pong;

interface JobOutboundMessageStart

interface JobOutboundMessageStart extends JobOutboundMessageBase {}

The job started. This is done by the job itself.

property kind

readonly kind: JobOutboundMessageKind.Start;

interface RegisterJobOptions

interface RegisterJobOptions extends Partial<JobDescription> {}

SimpleJobRegistry job registration options.

interface Registry

interface Registry<
    MinimumArgumentValueT extends JsonValue = JsonValue,
    MinimumInputValueT extends JsonValue = JsonValue,
    MinimumOutputValueT extends JsonValue = JsonValue
> {}

method get

get: <
    A extends MinimumArgumentValueT,
    I extends MinimumInputValueT,
    O extends MinimumOutputValueT
>(
    name: JobName
) => any;

Get a job handler.
Parameter name
The name of the job to get a handler from.

interface ScheduleJobOptions

interface ScheduleJobOptions {}

Options for scheduling jobs.

property dependencies

dependencies?: Job | Job[];

Jobs that need to finish before scheduling this job. These dependencies will be passed to the job itself in its context.

interface Scheduler

interface Scheduler<
    MinimumArgumentValueT extends JsonValue = JsonValue,
    MinimumInputValueT extends JsonValue = JsonValue,
    MinimumOutputValueT extends JsonValue = JsonValue
> {}

An interface that can schedule jobs.

method getDescription

getDescription: (name: JobName) => any;

Get a job description for a named job.
Parameter name
The name of the job.
Returns
A description, or null if no description is available for this job.

method has

has: (name: JobName) => any;

Returns true if the job name has been registered.
Parameter name
The name of the job.
Returns
True if the job exists, false otherwise.

method pause

pause: () => () => void;

Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be used to resume execution. If multiple pause() were called, all their resume functions must be called before the Scheduler actually starts new jobs. Additional calls to the same resume function will have no effect.
Jobs already running are NOT paused. This is pausing the scheduler only.
Returns
A function that can be run to resume the scheduler. If multiple pause() calls were made, all their return function must be called (in any order) before the scheduler can resume.

method schedule

schedule: <
    A extends MinimumArgumentValueT,
    I extends MinimumInputValueT,
    O extends MinimumOutputValueT
>(
    name: JobName,
    argument: A,
    options?: ScheduleJobOptions
) => Job<A, I, O>;

Schedule a job to be run, using its name.
Parameter name
The name of job to be run.
Parameter argument
The argument to send to the job when starting it.
Parameter options
Scheduling options.
Returns
The job being run.

interface SimpleJobHandlerContext

interface SimpleJobHandlerContext<
    A extends JsonValue,
    I extends JsonValue,
    O extends JsonValue
> extends JobHandlerContext<A, I, O> {}

Interface for the JobHandler context that is used when using createJobHandler(). It extends the basic JobHandlerContext with additional functionality.

property createChannel

createChannel: (name: string) => Observer<JsonValue>;

property input

input: Observable<I>;

enum JobInboundMessageKind

enum JobInboundMessageKind {
    Ping = 'ip',
    Stop = 'is',
    Input = 'in',
}

Messages that can be sent TO a job. The job needs to listen to those.

member Input

Input = 'in'

member Ping

Ping = 'ip'

member Stop

Stop = 'is'

enum JobOutboundMessageKind

enum JobOutboundMessageKind {
    OnReady = 'c',
    Start = 's',
    End = 'e',
    Pong = 'p',
    Output = 'o',
    ChannelCreate = 'cn',
    ChannelMessage = 'cm',
    ChannelError = 'ce',
    ChannelComplete = 'cc',
}

Kind of messages that can be outputted from a job.

member ChannelComplete

ChannelComplete = 'cc'

member ChannelCreate

ChannelCreate = 'cn'

member ChannelError

ChannelError = 'ce'

member ChannelMessage

ChannelMessage = 'cm'

member End

End = 'e'

member OnReady

OnReady = 'c'

member Output

Output = 'o'

member Pong

Pong = 'p'

member Start

Start = 's'

enum JobState

enum JobState {
    Queued = 'queued',
    Ready = 'ready',
    Started = 'started',
    Ended = 'ended',
    Errored = 'errored',
}

The state of a job. These are changed as the job reports a new state through its messages.

member Ended

Ended = 'ended'

The job has ended and is done running.

member Errored

Errored = 'errored'

An error occured and the job stopped because of internal state.

member Queued

Queued = 'queued'

The job was queued and is waiting to start.

member Ready

Ready = 'ready'

The job description was found, its dependencies (see "Synchronizing and Dependencies") are done running, and the job's argument is validated and the job's code will be executed.

member Started

Started = 'started'

The job has been started. The job implementation is expected to send this as soon as its work is starting.

type JobInboundMessage

type JobInboundMessage<InputT extends JsonValue> =
    | JobInboundMessagePing
    | JobInboundMessageStop
    | JobInboundMessageInput<InputT>;

type JobName

type JobName = string;

A job name is just a string (needs to be serializable).

type JobOutboundMessage

type JobOutboundMessage<OutputT extends JsonValue> =
    | JobOutboundMessageOnReady
    | JobOutboundMessageStart
    | JobOutboundMessageOutput<OutputT>
    | JobOutboundMessageChannelCreate
    | JobOutboundMessageChannelMessage
    | JobOutboundMessageChannelError
    | JobOutboundMessageChannelComplete
    | JobOutboundMessageEnd
    | JobOutboundMessagePong;

Generic message type.

type SimpleJobHandlerFn

type SimpleJobHandlerFn<
    A extends JsonValue,
    I extends JsonValue,
    O extends JsonValue
> = (
    input: A,
    context: SimpleJobHandlerContext<A, I, O>
) => O | Promise<O> | Observable<O>;

A simple version of the JobHandler. This simplifies a lot of the interaction with the job scheduler and registry. For example, instead of returning a JobOutboundMessage observable, you can directly return an output.

namespace experimental.jobs.strategy

namespace experimental.jobs.strategy {}

function memoize

memoize: <
    A extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray
>(
    replayMessages?: boolean
) => JobStrategy<A, I, O>;

Creates a JobStrategy that will reuse a running job if the argument matches.
Parameter replayMessages
Replay ALL messages if a job is reused, otherwise just hook up where it is.

function reuse

reuse: <
    A extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray
>(
    replayMessages?: boolean
) => JobStrategy<A, I, O>;

Creates a JobStrategy that will always reuse a running job, and restart it if the job ended.
Parameter replayMessages
Replay ALL messages if a job is reused, otherwise just hook up where it is.

function serialize

serialize: <
    A extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray,
    I extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray,
    O extends string | number | boolean | JsonObject | JsonArray =
        | string
        | number
        | boolean
        | JsonObject
        | JsonArray
>() => JobStrategy<A, I, O>;

Creates a JobStrategy that serializes every call. This strategy can be mixed between jobs.

type JobStrategy

type JobStrategy<
    A extends JsonValue = JsonValue,
    I extends JsonValue = JsonValue,
    O extends JsonValue = JsonValue
> = (
    handler: JobHandler<A, I, O>,
    options?: Partial<Readonly<JobDescription>>
) => JobHandler<A, I, O>;

namespace json

module 'src/json/index.d.ts' {}

function isJsonArray

isJsonArray: (value: JsonValue) => value is JsonArray;

function isJsonObject

isJsonObject: (value: JsonValue) => value is JsonObject;

function parseJson

parseJson: (
    input: string,
    mode?: JsonParseMode,
    options?: ParseJsonOptions
) => JsonValue;

Parse a JSON string into its value. This discards the AST and only returns the value itself.
If a path option is pass, it also absorbs JSON parsing errors and return a new error with the path in it. Useful for showing errors when parsing from a file.
Parameter input
The string to parse.
Parameter mode
The mode to parse the input with. .
Parameter options
Additional optinos for parsing.
Returns
{JsonValue} The value represented by the JSON string.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

function parseJsonAst

parseJsonAst: (input: string, mode?: JsonParseMode) => JsonAstNode;

Parse the JSON string and return its AST. The AST may be losing data (end comments are discarded for example, and space characters are not represented in the AST), but all values will have a single node in the AST (a 1-to-1 mapping).
Parameter input
The string to use.
Parameter mode
The mode to parse the input with. .
Returns
{JsonAstNode} The root node of the value of the AST.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

class InvalidJsonCharacterException

class InvalidJsonCharacterException extends JsonException {}

A character was invalid in this context.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

constructor

constructor(context: JsonParserContext);

property character

character: number;

property invalidChar

invalidChar: string;

property line

line: number;

property offset

offset: number;

class JsonException

class JsonException extends BaseException {}

class PathSpecificJsonException

class PathSpecificJsonException extends JsonException {}

An error happened within a file.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

constructor

constructor(path: string, exception: JsonException);

property exception

exception: JsonException;

property path

path: string;

class UnexpectedEndOfInputException

class UnexpectedEndOfInputException extends JsonException {}

More input was expected, but we reached the end of the stream.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

constructor

constructor(_context: JsonParserContext);

interface JsonArray

interface JsonArray extends Array<JsonValue> {}

interface JsonAstArray

interface JsonAstArray extends JsonAstNodeBase {}

property elements

readonly elements: JsonAstNode[];

property kind

readonly kind: 'array';

property value

readonly value: JsonArray;

interface JsonAstComment

interface JsonAstComment extends JsonAstNodeBase {}

property content

readonly content: string;

property kind

readonly kind: 'comment';

interface JsonAstConstantFalse

interface JsonAstConstantFalse extends JsonAstNodeBase {}

property kind

readonly kind: 'false';

property value

readonly value: false;

interface JsonAstConstantNull

interface JsonAstConstantNull extends JsonAstNodeBase {}

property kind

readonly kind: 'null';

property value

readonly value: null;

interface JsonAstConstantTrue

interface JsonAstConstantTrue extends JsonAstNodeBase {}

property kind

readonly kind: 'true';

property value

readonly value: true;

interface JsonAstIdentifier

interface JsonAstIdentifier extends JsonAstNodeBase {}

property kind

readonly kind: 'identifier';

property value

readonly value: string;

interface JsonAstKeyValue

interface JsonAstKeyValue extends JsonAstNodeBase {}

property key

readonly key: JsonAstString | JsonAstIdentifier;

property kind

readonly kind: 'keyvalue';

property value

readonly value: JsonAstNode;

interface JsonAstMultilineComment

interface JsonAstMultilineComment extends JsonAstNodeBase {}

property content

readonly content: string;

property kind

readonly kind: 'multicomment';

interface JsonAstNodeBase

interface JsonAstNodeBase {}

property comments

readonly comments?: (JsonAstComment | JsonAstMultilineComment)[];

property end

readonly end: Position;

property start

readonly start: Position;

property text

readonly text: string;

interface JsonAstNumber

interface JsonAstNumber extends JsonAstNodeBase {}

property kind

readonly kind: 'number';

property value

readonly value: number;

interface JsonAstObject

interface JsonAstObject extends JsonAstNodeBase {}

property kind

readonly kind: 'object';

property properties

readonly properties: JsonAstKeyValue[];

property value

readonly value: JsonObject;

interface JsonAstString

interface JsonAstString extends JsonAstNodeBase {}

property kind

readonly kind: 'string';

property value

readonly value: string;

interface JsonObject

interface JsonObject {}

index signature

[prop: string]: JsonValue;

interface JsonParserContext

interface JsonParserContext {}

Context passed around the parser with information about where we currently are in the parse.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

property mode

readonly mode: JsonParseMode;

property original

readonly original: string;

property position

position: Position;

property previous

previous: Position;

interface ParseJsonOptions

interface ParseJsonOptions {}

Options for the parseJson() function.
Deprecated
Deprecated since version 11. Use 3rd party JSON parsers such as jsonc-parser instead.

property path

path?: string;

If omitted, will only emit errors related to the content of the JSON. If specified, any JSON errors will also include the path of the file that caused the error.

interface Position

interface Position {}

property character

readonly character: number;

property line

readonly line: number;

property offset

readonly offset: number;

enum JsonParseMode

enum JsonParseMode {
    Strict = 0,
    CommentsAllowed = 1,
    SingleQuotesAllowed = 2,
    IdentifierKeyNamesAllowed = 4,
    TrailingCommasAllowed = 8,
    HexadecimalNumberAllowed = 16,
    MultiLineStringAllowed = 32,
    LaxNumberParsingAllowed = 64,
    NumberConstantsAllowed = 128,
    Default = 0,
    Loose = 255,
    Json = 0,
    Json5 = 255,
}

The Parse mode used for parsing the JSON string.

member CommentsAllowed

CommentsAllowed = 1

member Default

Default = 0

member HexadecimalNumberAllowed

HexadecimalNumberAllowed = 16

member IdentifierKeyNamesAllowed

IdentifierKeyNamesAllowed = 4

member Json

Json = 0

member Json5

Json5 = 255

member LaxNumberParsingAllowed

LaxNumberParsingAllowed = 64

member Loose

Loose = 255

member MultiLineStringAllowed

MultiLineStringAllowed = 32

member NumberConstantsAllowed

NumberConstantsAllowed = 128

member SingleQuotesAllowed

SingleQuotesAllowed = 2

member Strict

Strict = 0

member TrailingCommasAllowed

TrailingCommasAllowed = 8

type JsonAstNode

type JsonAstNode =
    | JsonAstNumber
    | JsonAstString
    | JsonAstIdentifier
    | JsonAstArray
    | JsonAstObject
    | JsonAstConstantFalse
    | JsonAstConstantNull
    | JsonAstConstantTrue;

type JsonValue

type JsonValue = JsonAstNode['value'];

namespace schema

module 'src/json/schema/index.d.ts' {}

function buildJsonPointer

buildJsonPointer: (fragments: string[]) => JsonPointer;

function getTypesOfSchema

getTypesOfSchema: (schema: JsonSchema) => Set<string>;

function isJsonSchema

isJsonSchema: (value: unknown) => value is JsonSchema;

function joinJsonPointer

joinJsonPointer: (root: JsonPointer, ...others: string[]) => JsonPointer;

function mergeSchemas

mergeSchemas: (...schemas: (JsonSchema | undefined)[]) => JsonSchema;

Return a schema that is the merge of all subschemas, ie. it should validate all the schemas that were passed in. It is possible to make an invalid schema this way, e.g. by using mergeSchemas({ type: 'number' }, { type: 'string' }), which will never validate.
Parameter schemas
All schemas to be merged.

function parseJsonPointer

parseJsonPointer: (pointer: JsonPointer) => string[];

function visitJson

visitJson: <ContextT>(
    json: JsonValue,
    visitor: JsonVisitor,
    schema?: JsonSchema,
    refResolver?: ReferenceResolver<ContextT>,
    context

@angular-devkit/core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable NormalizedRoot

variable NormalizedSep

variable path

Functions

function asPosixPath

function asWindowsPath

function basename

function clean

Deprecated

function deepCopy

function dirname

function extname

function fragment

function getSystemPath

function isAbsolute

function isJsonArray

function isJsonObject

function isPromise

function join

function mapObject

Deprecated

function noCacheNormalize

function normalize

Parameter path

function parseJson

Parameter input

Parameter mode

Parameter options

Returns

Deprecated

function parseJsonAst

Parameter input

Parameter mode

Returns

Deprecated

function relative

function resetNormalizeCache

function resolve

function split

Parameter path

Returns

function template

Parameter content

Parameter options

function templateParser

Classes

class BaseException

class CircularDependencyFoundException

class ContentHasMutatedException

class DependencyNotFoundException

class FileAlreadyExistException

class FileDoesNotExistException

class InvalidJsonCharacterException

Deprecated

property character

property invalidChar

property line

property offset

class InvalidPathException

class InvalidUpdateRecordException

class JsonException

class MergeConflictException

class PartiallyOrderedSet

property [Symbol.toStringTag]

property size

method [Symbol.iterator]

method add

method clear