@angular-devkit/core

@angular-devkit/core

Version 13.3.5
Published 13 days ago
441 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>(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 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 InvalidPathException

class InvalidPathException extends BaseException {}

constructor

constructor(path: string);

class InvalidUpdateRecordException

class InvalidUpdateRecordException extends BaseException {}

constructor

constructor();

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 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 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> {}

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

interface JsonObject

interface JsonObject {}

index signature

[prop: string]: JsonValue;

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;

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 JsonValue

type JsonValue = boolean | string | number | JsonArray | JsonObject | null;

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,
    AngularCLIMajorVersion = 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 AngularCLIMajorVersion

AngularCLIMajorVersion = 8

member BuildErrors

BuildErrors = 20

member CpuCount

CpuCount = 1

member CpuSpeed

CpuSpeed = 2

member NgAddCollection

NgAddCollection = 6

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 JsonValue,
    I extends JsonValue,
    O extends JsonValue
>(
    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 JsonValue,
    I extends JsonValue,
    O extends JsonValue
>(
    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 JsonValue,
    I extends JsonValue,
    O extends JsonValue
>(
    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 JsonValue, I extends JsonValue, O extends JsonValue>(
    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 JsonValue, I extends JsonValue, O extends JsonValue>(
    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
) => Observable<JobHandler<A, I, O>>;

class JobArgumentSchemaValidationError

class JobArgumentSchemaValidationError extends schema.SchemaValidationException {}

constructor

constructor(errors?: ErrorObject[]);

class JobDoesNotExistException

class JobDoesNotExistException extends BaseException {}

constructor

constructor(name: string);

class JobInboundMessageSchemaValidationError

class JobInboundMessageSchemaValidationError extends schema.SchemaValidationException {}

constructor

constructor(errors?: ErrorObject[]);

class JobNameAlreadyRegisteredException

class JobNameAlreadyRegisteredException extends BaseException {}

constructor

constructor(name: string);

class JobOutputSchemaValidationError

class JobOutputSchemaValidationError extends schema.SchemaValidationException {}

constructor

constructor(errors?: ErrorObject[]);

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
) => Observable<JobHandler<A, I, O>>;

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 JsonValue,
        InputT extends JsonValue,
        OutputT extends JsonValue
    >(
        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) => Observable<JobDescription>;

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) => Observable<boolean>;

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 JsonValue>(
    name: string,
    schema?: schema.JsonSchema
) => Observable<T>;

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: () => Observable<never>;

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
) => Observable<JobHandler<A, I, O>>;

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) => Observable<JobDescription>;

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) => Observable<boolean>;

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 JsonValue = JsonValue,
    I extends JsonValue = JsonValue,
    O extends JsonValue = JsonValue
>(
    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 JsonValue = JsonValue,
    I extends JsonValue = JsonValue,
    O extends JsonValue = JsonValue
>(
    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 JsonValue = JsonValue,
    I extends JsonValue = JsonValue,
    O extends JsonValue = JsonValue
>() => 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;

interface JsonArray

interface JsonArray extends Array<JsonValue> {}

interface JsonObject

interface JsonObject {}

index signature

[prop: string]: JsonValue;

type JsonValue

type JsonValue = boolean | string | number | JsonArray | JsonObject | null;

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?: ContextT
) => Observable<JsonValue>;

Visit all the properties in a JSON object, allowing to transform them. It supports calling properties synchronously or asynchronously (through Observables). The original object can be mutated or replaced entirely. In case where it's replaced, the new value is returned. When it's mutated though the original object will be changed.
Please note it is possible to have an infinite loop here (which will result in a stack overflow) if you return 2 objects that references each others (or the same object all the time).
Parameter json
The Json value to visit.
Parameter visitor
A function that will be called on every items.
Parameter schema
A JSON schema to pass through to the visitor (where possible).
Parameter refResolver
a function to resolve references in the schema.
Returns
{Observable< | undefined>} The observable of the new root, if the root changed.

function visitJsonSchema

visitJsonSchema: (schema: JsonSchema, visitor: JsonSchemaVisitor) => void;

class CoreSchemaRegistry

class CoreSchemaRegistry implements SchemaRegistry {}

constructor

constructor(formats?: SchemaFormat[]);

method addFormat

addFormat: (format: SchemaFormat) => void;

method addPostTransform

addPostTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;

Add a transformation step after the validation of any Json. The JSON will not be validated after the POST, so if transformations are not compatible with the Schema it will not result in an error.
Parameter visitor
The visitor to transform every value.
Parameter deps
A list of other visitors to run before.

method addPreTransform

addPreTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;

Add a transformation step before the validation of any Json.
Parameter visitor
The visitor to transform every value.
Parameter deps
A list of other visitors to run before.

method addSmartDefaultProvider

addSmartDefaultProvider: <T>(
    source: string,
    provider: SmartDefaultProvider<T>
) => void;

method compile

compile: (schema: JsonSchema) => Observable<SchemaValidator>;

Compile and return a validation function for the Schema.
Parameter schema
The schema to validate. If a string, will fetch the schema before compiling it (using schema as a URI).
Returns
An Observable of the Validation function.

method flatten

flatten: (schema: JsonObject) => Observable<JsonObject>;

Flatten the Schema, resolving and replacing all the refs. Makes it into a synchronous schema that is also easier to traverse. Does not cache the result.
Parameter schema
The schema or URI to flatten.
Returns
An Observable of the flattened schema object.
Deprecated
since 11.2 without replacement. Producing a flatten schema document does not in all cases produce a schema with identical behavior to the original. See: https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.appendix.B.2

method registerUriHandler

registerUriHandler: (handler: UriHandler) => void;

method usePromptProvider

usePromptProvider: (provider: PromptProvider) => void;

method useXDeprecatedProvider

useXDeprecatedProvider: (onUsage: (message: string) => void) => void;

class SchemaValidationException

class SchemaValidationException extends BaseException {}

constructor

constructor(errors?: ErrorObject[], baseMessage?: string);

property errors

readonly errors: ErrorObject[];

method createMessages

static createMessages: (errors?: SchemaValidatorError[]) => string[];

interface JsonSchemaVisitor

interface JsonSchemaVisitor {}

call signature

(
    current: JsonObject | JsonArray,
    pointer: JsonPointer,
    parentSchema?: JsonObject | JsonArray,
    index?: string
): void;

interface JsonVisitor

interface JsonVisitor {}

call signature

(
    value: JsonValue,
    pointer: JsonPointer,
    schema?: JsonObject,
    root?: JsonObject | JsonArray
): Observable<JsonValue> | JsonValue;

interface PromptDefinition

interface PromptDefinition {}

property default

default?: string | string[] | number | boolean | null;

property id

id: string;

property items

items?: Array<
    | string
    | {
          value: JsonValue;
          label: string;
      }
>;

property message

message: string;

property multiselect

multiselect?: boolean;

property propertyTypes

propertyTypes: Set<string>;

property raw

raw?: string | JsonObject;

property type

type: string;

property validator

validator?: (value: JsonValue) => boolean | string | Promise<boolean | string>;

interface ReferenceResolver

interface ReferenceResolver<ContextT> {}

call signature

(ref: string, context?: ContextT): {
    context?: ContextT;
    schema?: JsonObject;
};

interface SchemaFormat

interface SchemaFormat {}

property formatter

formatter: SchemaFormatter;

property name

name: string;

interface SchemaKeywordValidator

interface SchemaKeywordValidator {}

call signature

(
    data: JsonValue,
    schema: JsonValue,
    parent: JsonObject | JsonArray | undefined,
    parentProperty: string | number | undefined,
    pointer: JsonPointer,
    rootData: JsonValue
): boolean | Observable<boolean>;

interface SchemaRegistry

interface SchemaRegistry {}

method addFormat

addFormat: (format: SchemaFormat) => void;

method addPostTransform

addPostTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;

Add a transformation step after the validation of any Json. The JSON will not be validated after the POST, so if transformations are not compatible with the Schema it will not result in an error.
Parameter visitor
The visitor to transform every value.
Parameter deps
A list of other visitors to run before.

method addPreTransform

addPreTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;

Add a transformation step before the validation of any Json.
Parameter visitor
The visitor to transform every value.
Parameter deps
A list of other visitors to run before.

method addSmartDefaultProvider

addSmartDefaultProvider: <T>(
    source: string,
    provider: SmartDefaultProvider<T>
) => void;

method compile

compile: (schema: Object) => Observable<SchemaValidator>;

method flatten

flatten: (schema: JsonObject | string) => Observable<JsonObject>;

Deprecated
since 11.2 without replacement. Producing a flatten schema document does not in all cases produce a schema with identical behavior to the original. See: https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.appendix.B.2

method usePromptProvider

usePromptProvider: (provider: PromptProvider) => void;

method useXDeprecatedProvider

useXDeprecatedProvider: (onUsage: (message: string) => void) => void;

interface SchemaValidator

interface SchemaValidator {}

call signature

(
    data: JsonValue,
    options?: SchemaValidatorOptions
): Observable<SchemaValidatorResult>;

interface SchemaValidatorOptions

interface SchemaValidatorOptions {}

property applyPostTransforms

applyPostTransforms?: boolean;

property applyPreTransforms

applyPreTransforms?: boolean;

property withPrompts

withPrompts?: boolean;

interface SchemaValidatorResult

interface SchemaValidatorResult {}

property data

data: JsonValue;

property errors

errors?: SchemaValidatorError[];

property success

success: boolean;

interface SmartDefaultProvider

interface SmartDefaultProvider<T> {}

call signature

(schema: JsonObject): T | Observable<T>;

type JsonPointer

type JsonPointer = string & {
    __PRIVATE_DEVKIT_JSON_POINTER: void;
};

type JsonSchema

type JsonSchema = JsonObject | boolean;

A specialized interface for JsonSchema (to come). JsonSchemas are also JsonObject.
Modifiers
- @public

type PromptProvider

type PromptProvider = (
    definitions: Array<PromptDefinition>
) => SubscribableOrPromise<{
    [id: string]: JsonValue;
}>;

type SchemaFormatter

type SchemaFormatter = Format;

type SchemaValidatorError

type SchemaValidatorError = Partial<ErrorObject>;

type UriHandler

type UriHandler = (
    uri: string
) => Observable<JsonObject> | Promise<JsonObject> | null | undefined;

namespace transforms

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

function addUndefinedDefaults

addUndefinedDefaults: (
    value: JsonValue,
    _pointer: JsonPointer,
    schema?: JsonSchema
) => JsonValue;

namespace logging

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

class IndentLogger

class IndentLogger extends Logger {}

constructor

constructor(name: string, parent?: Logger, indentation?: string);

class LevelCapLogger

class LevelCapLogger extends LevelTransformLogger {}

constructor

constructor(name: string, parent: Logger, levelCap: LogLevel);

property levelCap

readonly levelCap: LogLevel;

property levelMap

static levelMap: { [cap: string]: { [level: string]: string } };

property name

readonly name: string;

property parent

readonly parent: Logger;

class LevelTransformLogger

class LevelTransformLogger extends Logger {}

constructor

constructor(
    name: string,
    parent: Logger,
    levelTransform: (level: LogLevel) => LogLevel
);

property levelTransform

readonly levelTransform: (level: LogLevel) => LogLevel;

property name

readonly name: string;

property parent

readonly parent: Logger;

method createChild

createChild: (name: string) => Logger;

method log

log: (level: LogLevel, message: string, metadata?: JsonObject) => void;

class Logger

class Logger extends Observable<LogEntry> implements LoggerApi {}

constructor

constructor(name: string, parent?: Logger);

property name

readonly name: string;

property parent

readonly parent: Logger;

method asApi

asApi: () => LoggerApi;

method complete

complete: () => void;

method createChild

createChild: (name: string) => Logger;

method debug

debug: (message: string, metadata?: JsonObject) => void;

method error

error: (message: string, metadata?: JsonObject) => void;

method fatal

fatal: (message: string, metadata?: JsonObject) => void;

method forEach

forEach: (
    next: (value: LogEntry) => void,
    PromiseCtor?: typeof Promise
) => Promise<void>;

method info

info: (message: string, metadata?: JsonObject) => void;

method lift

lift: <R>(operator: Operator<LogEntry, R>) => Observable<R>;

method log

log: (level: LogLevel, message: string, metadata?: JsonObject) => void;

method next

next: (entry: LogEntry) => void;

subscribe: {
    (): Subscription;
    (observer: PartialObserver<LogEntry>): Subscription;
    (
        next?: (value: LogEntry) => void,
        error?: (error: Error) => void,
        complete?: () => void
    ): Subscription;
};

method toString

toString: () => string;

method warn

warn: (message: string, metadata?: JsonObject) => void;

class NullLogger

class NullLogger extends Logger {}

constructor

constructor(parent?: Logger);

method asApi

asApi: () => LoggerApi;

class TransformLogger

class TransformLogger extends Logger {}

constructor

constructor(
    name: string,
    transform: (stream: Observable<LogEntry>) => Observable<LogEntry>,
    parent?: Logger
);

interface LogEntry

interface LogEntry extends LoggerMetadata {}

property level

level: LogLevel;

property message

message: string;

property timestamp

timestamp: number;

interface LoggerApi

interface LoggerApi {}

method createChild

createChild: (name: string) => Logger;

method debug

debug: (message: string, metadata?: JsonObject) => void;

method error

error: (message: string, metadata?: JsonObject) => void;

method fatal

fatal: (message: string, metadata?: JsonObject) => void;

method info

info: (message: string, metadata?: JsonObject) => void;

method log

log: (level: LogLevel, message: string, metadata?: JsonObject) => void;

method warn

warn: (message: string, metadata?: JsonObject) => void;

interface LoggerMetadata

interface LoggerMetadata extends JsonObject {}

property name

name: string;

property path

path: string[];

type LogLevel

type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';

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?: ContextT
) => Observable<JsonValue>;

Visit all the properties in a JSON object, allowing to transform them. It supports calling properties synchronously or asynchronously (through Observables). The original object can be mutated or replaced entirely. In case where it's replaced, the new value is returned. When it's mutated though the original object will be changed.
Please note it is possible to have an infinite loop here (which will result in a stack overflow) if you return 2 objects that references each others (or the same object all the time).
Parameter json
The Json value to visit.
Parameter visitor
A function that will be called on every items.
Parameter schema
A JSON schema to pass through to the visitor (where possible).
Parameter refResolver
a function to resolve references in the schema.
Returns
{Observable< | undefined>} The observable of the new root, if the root changed.

function visitJsonSchema

visitJsonSchema: (schema: JsonSchema, visitor: JsonSchemaVisitor) => void;

class CoreSchemaRegistry

class CoreSchemaRegistry implements SchemaRegistry {}

constructor

constructor(formats?: SchemaFormat[]);

method addFormat

addFormat: (format: SchemaFormat) => void;

method addPostTransform

addPostTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;

Add a transformation step after the validation of any Json. The JSON will not be validated after the POST, so if transformations are not compatible with the Schema it will not result in an error.
Parameter visitor
The visitor to transform every value.
Parameter deps
A list of other visitors to run before.

method addPreTransform

addPreTransform: (visitor: JsonVisitor, deps?: JsonVisitor[]) => void;

Add a transformation step before the validation of any Json.
Parameter visitor
The visitor to transform every value.
Parameter deps
A list of other visitors to run before.

method addSmartDefaultProvider

addSmartDefaultProvider: <T>(
    source: string,
    provider: SmartDefaultProvider<T>
) => void;

method compile

compile: (schema: JsonSchema) => Observable<SchemaValidator>;

Compile and return a validation function for the Schema.
Parameter schema
The schema to validate. If a string, will fetch the schema before compiling it (using schema as a URI).
Returns
An Observable of the Validation function.

method flatten

flatten: (schema: JsonObject) => Observable<JsonObject>;

Flatten the Schema, resolving and replacing all the refs. Makes it into a synchronous schema that is also easier to traverse. Does not cache the result.
Parameter schema
The schema or URI to flatten.
Returns
An Observable of the flattened schema object.
Deprecated
since 11.2 without replacement. Producing a flatten schema document does not in all cases produce a schema with identical behavior to the original. See: https://json-schema.org/draft/2019-09/json-schema-core.html#rfc.appendix.B.2

method registerUriHandler

registerUriHandler: (handler: UriHandler) => void;

method usePromptProvider

usePromptProvider: (provider: PromptProvider) => void;

method useXDeprecatedProvider

useXDeprecatedProvider: (onUsage: (message: string) => void) => void;

class SchemaValidationException

class SchemaValidationException extends BaseException {}

constructor

constructor(errors?: ErrorObject[], baseMessage?: string);

property errors

readonly errors: ErrorObject[];

method createMessages

static createMessages: (errors?: SchemaValidatorError[]) => string[];

interface JsonSchemaVisitor

interface JsonSchemaVisitor {}

call signature

(
    current: JsonObject | JsonArray,
    pointer: JsonPointer,
    parentSchema?: JsonObject | JsonArray,
    index?: string
): void;

interface JsonVisitor

interface JsonVisitor {}

call signature

(
    value: JsonValue,
    pointer: JsonPointer,
    schema?: JsonObject,
    root?: JsonObject | JsonArray
): Observable<JsonValue> | JsonValue;

interface PromptDefinition

interface PromptDefinition {}

property default

default?: string | string[] | number | boolean | null;

property id

id: string;

property items

items?: Array<
    | string
    | {
          value: JsonValue;
          label: string;
      }
>;

property message

message: string;

property multiselect

multiselect?: boolean;

property propertyTypes

propertyTypes: Set<string>;

property raw

raw?: string | JsonObject;

@angular-devkit/core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

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 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 InvalidPathException

class InvalidUpdateRecordException

class MergeConflictException

class PartiallyOrderedSet

property [Symbol.toStringTag]

property size

method [Symbol.iterator]

method add

method clear

method delete

method entries

method forEach

method has

method keys

method values

class PathCannotBeFragmentException

class PathIsDirectoryException

class PathIsFileException

class PathMustBeAbsoluteException

class PriorityQueue

property size

method clear

method peek

method pop

method push

method toArray

class UnimplementedException

class UnknownException