@angular-devkit/core

@angular-devkit/core

Version 15.0.2
Published 6 days ago
270 kB
5 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 deepCopy

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

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

Deprecated
since version 14. Use the same symbol from @angular-devkit/schematics.

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

Deprecated
since version 14. Use the same symbol from @angular-devkit/schematics.

constructor

constructor();

class MergeConflictException

class MergeConflictException extends BaseException {}

Deprecated
since version 14. Use the same symbol from @angular-devkit/schematics.

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

Deprecated
since version 14. Create a custom exception implementation instead.

constructor

constructor();

class UnknownException

class UnknownException extends BaseException {}

constructor

constructor(message: string);

class UnsupportedPlatformException

class UnsupportedPlatformException extends BaseException {}

Deprecated
since version 14. Create a custom exception implementation instead.

constructor

constructor();

Interfaces

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

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

type WindowsPath

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

Namespaces

namespace json

module 'src/json/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 isJsonArray

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

function isJsonObject

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

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;

type JsonValue

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

namespace schema

module 'src/json/schema/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 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' {}

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 addUndefinedDefaults

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

namespace logging

module 'src/logger/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

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?: PromiseConstructorLike
) => 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' {}

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

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 addUndefinedDefaults

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

namespace strings

module 'src/utils/strings.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 camelize

camelize: (str: string) => string;

Returns the lowerCamelCase form of a string.
```javascript camelize('innerHTML'); // 'innerHTML' camelize('action_name'); // 'actionName' camelize('css-class-name'); // 'cssClassName' camelize('my favorite items'); // 'myFavoriteItems' camelize('My Favorite Items'); // 'myFavoriteItems' ```
camelize
Parameter str
The string to camelize. {String} the camelized string.

function capitalize

capitalize: (str: string) => string;

Returns the Capitalized form of a string
```javascript 'innerHTML'.capitalize() // 'InnerHTML' 'action_name'.capitalize() // 'Action_name' 'css-class-name'.capitalize() // 'Css-class-name' 'my favorite items'.capitalize() // 'My favorite items' ```
capitalize
Parameter str
The string to capitalize. {String} The capitalized string.

function classify

classify: (str: string) => string;

Returns the UpperCamelCase form of a string.
Parameter str
the string to classify {String} the classified string
Example 1
```javascript 'innerHTML'.classify(); // 'InnerHTML' 'action_name'.classify(); // 'ActionName' 'css-class-name'.classify(); // 'CssClassName' 'my favorite items'.classify(); // 'MyFavoriteItems' 'app.component'.classify(); // 'AppComponent' ``` classify

function dasherize

dasherize: (str: string) => string;

Replaces underscores, spaces, or camelCase with dashes.
```javascript dasherize('innerHTML'); // 'inner-html' dasherize('action_name'); // 'action-name' dasherize('css-class-name'); // 'css-class-name' dasherize('my favorite items'); // 'my-favorite-items' ```
dasherize
Parameter str
The string to dasherize. {String} the dasherized string.

function decamelize

decamelize: (str: string) => string;

Converts a camelized string into all lower case separated by underscores.
```javascript decamelize('innerHTML'); // 'inner_html' decamelize('action_name'); // 'action_name' decamelize('css-class-name'); // 'css-class-name' decamelize('my favorite items'); // 'my favorite items' ```
decamelize
Parameter str
The string to decamelize. {String} the decamelized string.

function levenshtein

levenshtein: (a: string, b: string) => number;

Calculate the levenshtein distance of two strings. See https://en.wikipedia.org/wiki/Levenshtein_distance. Based off https://gist.github.com/andrei-m/982927 (for using the faster dynamic programming version).
Parameter a
String a.
Parameter b
String b.
Returns
A number that represents the distance between the two strings. The greater the number the more distant the strings are from each others.

function underscore

underscore: (str: string) => string;

More general than decamelize. Returns the lower_case_and_underscored form of a string.
```javascript 'innerHTML'.underscore(); // 'inner_html' 'action_name'.underscore(); // 'action_name' 'css-class-name'.underscore(); // 'css_class_name' 'my favorite items'.underscore(); // 'my_favorite_items' ```
underscore
Parameter str
The string to underscore. {String} the underscored string.

namespace tags

module 'src/utils/literals.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 indentBy

indentBy: (indentations: number) => TemplateTag;

function oneLine

oneLine: (strings: TemplateStringsArray, ...values: any[]) => string;

function stripIndent

stripIndent: (strings: TemplateStringsArray, ...values: any[]) => string;

function stripIndents

stripIndents: (strings: TemplateStringsArray, ...values: any[]) => string;

function trimNewlines

trimNewlines: (strings: TemplateStringsArray, ...values: any[]) => string;

interface TemplateTag

interface TemplateTag<R = string> {}

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

call signature

(template: TemplateStringsArray, ...substitutions: any[]): R;

namespace virtualFs

module 'src/virtual-fs/host/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 fileBuffer

const fileBuffer: TemplateTag<ArrayBuffer>;

function createSyncHost

createSyncHost: <StatsT extends object = {}>(
    handler: SyncHostHandler<StatsT>
) => Host<StatsT>;

function fileBufferToString

fileBufferToString: (fileBuffer: FileBuffer) => string;

function stringToFileBuffer

stringToFileBuffer: (str: string) => FileBuffer;

class AliasHost

class AliasHost<StatsT extends object = {}> extends ResolverHost<StatsT> {}

A Virtual Host that allow to alias some paths to other paths.
This does not verify, when setting an alias, that the target or source exist. Neither does it check whether it's a file or a directory. Please not that directories are also renamed/replaced.
No recursion is done on the resolution, which means the following is perfectly valid then:
host.aliases.set(normalize('/file/a'), normalize('/file/b')); host.aliases.set(normalize('/file/b'), normalize('/file/a'));
This will result in a proper swap of two files for each others.
Example 1
const host = new SimpleMemoryHost(); host.write(normalize('/some/file'), content).subscribe();
const aHost = new AliasHost(host); aHost.read(normalize('/some/file')) .subscribe(x => expect(x).toBe(content)); aHost.aliases.set(normalize('/some/file'), normalize('/other/path');
// This file will not exist because /other/path does not exist. aHost.read(normalize('/some/file')) .subscribe(undefined, err => expect(err.message).toMatch(/does not exist/));
Example 2
const host = new SimpleMemoryHost(); host.write(normalize('/some/folder/file'), content).subscribe();
const aHost = new AliasHost(host); aHost.read(normalize('/some/folder/file')) .subscribe(x => expect(x).toBe(content)); aHost.aliases.set(normalize('/some'), normalize('/other');
// This file will not exist because /other/path does not exist. aHost.read(normalize('/some/folder/file')) .subscribe(undefined, err => expect(err.message).toMatch(/does not exist/));
// Create the file with new content and verify that this has the new content. aHost.write(normalize('/other/folder/file'), content2).subscribe(); aHost.read(normalize('/some/folder/file')) .subscribe(x => expect(x).toBe(content2));

property aliases

readonly aliases: Map<Path, Path>;

class CordHost

class CordHost extends SimpleMemoryHost {}

A Host that records changes to the underlying Host, while keeping a record of Create, Overwrite, Rename and Delete of files.
This is fully compatible with Host, but will keep a staging of every changes asked. That staging follows the principle of the Tree (e.g. can create a file that already exists).
Using create() and overwrite() will force those operations, but using write will add the create/overwrite records IIF the files does/doesn't already exist.

constructor

constructor(_back: ReadonlyHost<{}>);

property backend

readonly backend: ReadonlyHost<{}>;

property capabilities

readonly capabilities: HostCapabilities;

method clone

clone: () => CordHost;

Create a copy of this host, including all actions made.
Returns
{CordHost} The carbon copy.

method commit

commit: (host: Host, force?: boolean) => Observable<void>;

Commit the changes recorded to a Host. It is assumed that the host does have the same structure as the host that was used for backend (could be the same host).
Parameter host
The host to create/delete/rename/overwrite files to.
Parameter force
Whether to skip existence checks when creating/overwriting. This is faster but might lead to incorrect states. Because Hosts natively don't support creation versus overwriting (it's only writing), we check for existence before completing a request.
Returns
An observable that completes when done, or error if an error occured.

method create

create: (path: Path, content: FileBuffer) => Observable<void>;

Specialized version of CordHost#write which forces the creation of a file whether it exists or not.
Parameter path
Parameter content
Returns
{Observable}

method delete

delete: (path: Path) => Observable<void>;

method exists

exists: (path: Path) => Observable<boolean>;

method isDirectory

isDirectory: (path: Path) => Observable<boolean>;

method isFile

isFile: (path: Path) => Observable<boolean>;

method list

list: (path: Path) => Observable<PathFragment[]>;

method overwrite

overwrite: (path: Path, content: FileBuffer) => Observable<void>;

method read

read: (path: Path) => Observable<ArrayBuffer>;

method records

records: () => CordHostRecord[];

method rename

rename: (from: Path, to: Path) => Observable<void>;

method stat

stat: (path: Path) => Observable<Stats | null> | null;

method watch

watch: (path: Path, options?: HostWatchOptions) => null;

method willCreate

willCreate: (path: Path) => boolean;

method willDelete

willDelete: (path: Path) => boolean;

method willOverwrite

willOverwrite: (path: Path) => boolean;

method willRename

willRename: (path: Path) => boolean;

method willRenameTo

willRenameTo: (path: Path, to: Path) => boolean;

method write

write: (path: Path, content: FileBuffer) => Observable<void>;

class Empty

class Empty implements ReadonlyHost {}

property capabilities

readonly capabilities: HostCapabilities;

method exists

exists: (path: Path) => Observable<boolean>;

method isDirectory

isDirectory: (path: Path) => Observable<boolean>;

method isFile

isFile: (path: Path) => Observable<boolean>;

method list

list: (path: Path) => Observable<PathFragment[]>;

method read

read: (path: Path) => Observable<ArrayBuffer>;

method stat

stat: (
    path: Path
) => Observable<{
    isFile(): boolean;
    isDirectory(): boolean;
    readonly size: number;
    readonly atime: Date;
    readonly mtime: Date;
    readonly ctime: Date;
    readonly birthtime: Date;
}>;

class PatternMatchingHost

class PatternMatchingHost<StatsT extends object = {}> extends ResolverHost<StatsT> {}

method addPattern

addPattern: (
    pattern: string | string[],
    replacementFn: ReplacementFunction
) => void;

class ResolverHost

abstract class ResolverHost<T extends object> implements Host<T> {}

A Host that runs a method before calling its delegate. This is an abstract class and its actual behaviour is entirely dependant of the subclass.

constructor

constructor(_delegate: Host<T>);

property capabilities

readonly capabilities: HostCapabilities;

method delete

delete: (path: Path) => Observable<void>;

method exists

exists: (path: Path) => Observable<boolean>;

method isDirectory

isDirectory: (path: Path) => Observable<boolean>;

method isFile

isFile: (path: Path) => Observable<boolean>;

method list

list: (path: Path) => Observable<PathFragment[]>;

method read

read: (path: Path) => Observable<ArrayBuffer>;

method rename

rename: (from: Path, to: Path) => Observable<void>;

method stat

stat: (path: Path) => Observable<Stats<T> | null> | null;

method watch

watch: (
    path: Path,
    options?: HostWatchOptions
) => Observable<HostWatchEvent> | null;

method write

write: (path: Path, content: FileBuffer) => Observable<void>;

class SafeReadonlyHost

class SafeReadonlyHost<StatsT extends object = {}> implements ReadonlyHost<StatsT> {}

A Host that filters out errors. The only exception is read() which will still error out if the delegate returned an error (e.g. NodeJS will error out if the file doesn't exist).

constructor

constructor(_delegate: ReadonlyHost<StatsT>);

property capabilities

readonly capabilities: HostCapabilities;

method exists

exists: (path: Path) => Observable<boolean>;

method isDirectory

isDirectory: (path: Path) => Observable<boolean>;

method isFile

isFile: (path: Path) => Observable<boolean>;

method list

list: (path: Path) => Observable<PathFragment[]>;

method read

read: (path: Path) => Observable<ArrayBuffer>;

method stat

stat: (path: Path) => Observable<Stats<StatsT> | null> | null;

class ScopedHost

class ScopedHost<T extends object> extends ResolverHost<T> {}

constructor

constructor(delegate: Host<T>, _root?: String & { __PRIVATE_DEVKIT_PATH: void });

class SimpleMemoryHost

class SimpleMemoryHost implements Host<{}> {}

constructor

constructor();

property capabilities

readonly capabilities: HostCapabilities;

method delete

delete: (path: Path) => Observable<void>;

method exists

exists: (path: Path) => Observable<boolean>;

method isDirectory

isDirectory: (path: Path) => Observable<boolean>;

method isFile

isFile: (path: Path) => Observable<boolean>;

method list

list: (path: Path) => Observable<PathFragment[]>;

method read

read: (path: Path) => Observable<ArrayBuffer>;

method rename

rename: (from: Path, to: Path) => Observable<void>;

method reset

reset: () => void;

method stat

stat: (path: Path) => Observable<Stats<{}> | null> | null;

method watch

watch: (
    path: Path,
    options?: HostWatchOptions
) => Observable<HostWatchEvent> | null;

method write

write: (path: Path, content: FileBuffer) => Observable<void>;

class SyncDelegateHost

class SyncDelegateHost<T extends object = {}> {}

Implement a synchronous-only host interface (remove the Observable parts).

constructor

constructor(_delegate: Host<T>);

property capabilities

readonly capabilities: HostCapabilities;

property delegate

readonly delegate: Host<T>;

method delete

delete: (path: Path) => void;

method exists

exists: (path: Path) => boolean;

method isDirectory

isDirectory: (path: Path) => boolean;

method isFile

isFile: (path: Path) => boolean;

method list

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

method read

read: (path: Path) => FileBuffer;

method rename

rename: (from: Path, to: Path) => void;

method stat

stat: (path: Path) => Stats<T> | null;

method watch

watch: (
    path: Path,
    options?: HostWatchOptions
) => Observable<HostWatchEvent> | null;

method write

write: (path: Path, content: FileBufferLike) => void;

class SynchronousDelegateExpectedException

class SynchronousDelegateExpectedException extends BaseException {}

constructor

constructor();

interface CordHostCreate

interface CordHostCreate {}

property content

content: FileBuffer;

property kind

kind: 'create';

property path

path: Path;

interface CordHostDelete

interface CordHostDelete {}

property kind

kind: 'delete';

property path

path: Path;

interface CordHostOverwrite

interface CordHostOverwrite {}

property content

content: FileBuffer;

property kind

kind: 'overwrite';

property path

path: Path;

interface CordHostRename

interface CordHostRename {}

property from

from: Path;

property kind

kind: 'rename';

property to

to: Path;

interface Host

interface Host<StatsT extends object = {}> extends ReadonlyHost<StatsT> {}

method delete

delete: (path: Path) => Observable<void>;

method rename

rename: (from: Path, to: Path) => Observable<void>;

method watch

watch: (
    path: Path,
    options?: HostWatchOptions
) => Observable<HostWatchEvent> | null;

method write

write: (path: Path, content: FileBufferLike) => Observable<void>;

interface HostCapabilities

interface HostCapabilities {}

property synchronous

synchronous: boolean;

interface HostWatchEvent

interface HostWatchEvent {}

property path

readonly path: Path;

property time

readonly time: Date;

property type

readonly type: HostWatchEventType;

interface HostWatchOptions

interface HostWatchOptions {}

property persistent

readonly persistent?: boolean;

property recursive

readonly recursive?: boolean;

interface ReadonlyHost

interface ReadonlyHost<StatsT extends object = {}> {}

property capabilities

readonly capabilities: HostCapabilities;

method exists

exists: (path: Path) => Observable<boolean>;

method isDirectory

isDirectory: (path: Path) => Observable<boolean>;

method isFile

isFile: (path: Path) => Observable<boolean>;

method list

list: (path: Path) => Observable<PathFragment[]>;

method read

read: (path: Path) => Observable<ArrayBuffer>;

method stat

stat: (path: Path) => Observable<Stats<StatsT> | null> | null;

interface SimpleMemoryHostStats

interface SimpleMemoryHostStats {}

property content

readonly content: FileBuffer | null;

interface SyncHostHandler

interface SyncHostHandler<StatsT extends object = {}> {}

method delete

delete: (path: Path) => void;

method exists

exists: (path: Path) => boolean;

method isDirectory

isDirectory: (path: Path) => boolean;

method isFile

isFile: (path: Path) => boolean;

method list

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

method read

read: (path: Path) => FileBuffer;

method rename

rename: (from: Path, to: Path) => void;

method stat

stat: (path: Path) => Stats<StatsT> | null;

method write

write: (path: Path, content: FileBufferLike) => void;

enum HostWatchEventType

const enum HostWatchEventType {
    Changed = 0,
    Created = 1,
    Deleted = 2,
    Renamed = 3,
}

member Changed

Changed = 0

member Created

Created = 1

member Deleted

Deleted = 2

member Renamed

Renamed = 3

type CordHostRecord

type CordHostRecord =
    | CordHostCreate
    | CordHostOverwrite
    | CordHostRename
    | CordHostDelete;

type FileBuffer

type FileBuffer = ArrayBuffer;

type FileBufferLike

type FileBufferLike = ArrayBufferLike;

type ReplacementFunction

type ReplacementFunction = (path: Path) => Path;

type Stats

type Stats<T extends object = {}> = T & {
    isFile(): boolean;
    isDirectory(): boolean;
    readonly size: number;
    readonly atime: Date;
    readonly mtime: Date;
    readonly ctime: Date;
    readonly birthtime: Date;
};

namespace virtualFs.test

namespace virtualFs.test {}

class TestHost

class TestHost extends SimpleMemoryHost {}

constructor

constructor(map?: { [path: string]: string });

property files

readonly files: Path[];

property records

readonly records: TestLogRecord[];

property sync

readonly sync: SyncDelegateHost<{}>;

method $exists

$exists: (path: string) => boolean;

method $isDirectory

$isDirectory: (path: string) => boolean;

method $isFile

$isFile: (path: string) => boolean;

method $list

$list: (path: string) => PathFragment[];

method $read

$read: (path: string) => string;

method $write

$write: (path: string, content: string) => void;

method clearRecords

clearRecords: () => void;

method clone

clone: () => TestHost;

type TestLogRecord

type TestLogRecord =
    | {
          kind:
              | 'write'
              | 'read'
              | 'delete'
              | 'list'
              | 'exists'
              | 'isDirectory'
              | 'isFile'
              | 'stat'
              | 'watch';
          path: Path;
      }
    | {
          kind: 'rename';
          from: Path;
          to: Path;
      };

namespace workspaces

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

function createWorkspaceHost

createWorkspaceHost: (host: virtualFs.Host) => WorkspaceHost;

function readWorkspace

readWorkspace: (
    path: string,
    host: WorkspaceHost,
    format?: WorkspaceFormat
) => Promise<{ workspace: WorkspaceDefinition }>;

Reads and constructs a WorkspaceDefinition. If the function is provided with a path to a directory instead of a file, a search of the directory's files will commence to attempt to locate a known workspace file. Currently the following are considered known workspace files: - angular.json - .angular.json
Parameter path
The path to either a workspace file or a directory containing a workspace file.
Parameter host
The WorkspaceHost to use to access the file and directory data.
Parameter format
An optional WorkspaceFormat value. Used if the path specifies a non-standard file name that would prevent automatically discovering the format.
An Promise of the read result object with the WorkspaceDefinition contained within the workspace property.

function writeWorkspace

writeWorkspace: (
    workspace: WorkspaceDefinition,
    host: WorkspaceHost,
    path?: string,
    format?: WorkspaceFormat
) => Promise<void>;

Writes a WorkspaceDefinition to the underlying storage via the provided WorkspaceHost. If the WorkspaceDefinition was created via the readWorkspace function, metadata will be used to determine the path and format of the Workspace. In all other cases, the path and format options must be specified as they would be otherwise unknown.
Parameter workspace
The WorkspaceDefinition that will be written.
Parameter host
The WorkspaceHost to use to access/write the file and directory data.
Parameter path
The path to a file location for the output. Required if readWorkspace was not used to create the WorkspaceDefinition. Optional otherwise; will override the WorkspaceDefinition metadata if provided.
Parameter format
The WorkspaceFormat to use for output. Required if readWorkspace was not used to create the WorkspaceDefinition. Optional otherwise; will override the WorkspaceDefinition metadata if provided.
An Promise of type void.

class ProjectDefinitionCollection

class ProjectDefinitionCollection extends DefinitionCollection<ProjectDefinition> {}

constructor

constructor(
    initial?: Record<string, ProjectDefinition>,
    listener?: DefinitionCollectionListener<ProjectDefinition>
);

method add

add: (definition: {
    [key: string]: unknown;
    name: string;
    root: string;
    sourceRoot?: string;
    prefix?: string;
    targets?: Record<string, TargetDefinition | undefined>;
}) => ProjectDefinition;

method set

set: (name: string, value: ProjectDefinition) => this;

class TargetDefinitionCollection

class TargetDefinitionCollection extends DefinitionCollection<TargetDefinition> {}

constructor

constructor(
    initial?: Record<string, TargetDefinition>,
    listener?: DefinitionCollectionListener<TargetDefinition>
);

method add

add: (definition: { name: string } & TargetDefinition) => TargetDefinition;

method set

set: (name: string, value: TargetDefinition) => this;

interface ProjectDefinition

interface ProjectDefinition {}

property extensions

readonly extensions: Record<string, JsonValue | undefined>;

property prefix

prefix?: string;

property root

root: string;

property sourceRoot

sourceRoot?: string;

property targets

readonly targets: TargetDefinitionCollection;

interface TargetDefinition

interface TargetDefinition {}

property builder

builder: string;

property configurations

configurations?: Record<
    string,
    Record<string, JsonValue | undefined> | undefined
>;

property defaultConfiguration

defaultConfiguration?: string;

property options

options?: Record<string, JsonValue | undefined>;

interface WorkspaceDefinition

interface WorkspaceDefinition {}

property extensions

readonly extensions: Record<string, JsonValue | undefined>;

property projects

readonly projects: ProjectDefinitionCollection;

interface WorkspaceHost

interface WorkspaceHost {}

method isDirectory

isDirectory: (path: string) => Promise<boolean>;

method isFile

isFile: (path: string) => Promise<boolean>;

method readFile

readFile: (path: string) => Promise<string>;

method writeFile

writeFile: (path: string, data: string) => Promise<void>;

enum WorkspaceFormat

enum WorkspaceFormat {
    JSON = 0,
}

Supported workspace formats

member JSON

JSON = 0

type DefinitionCollectionListener

type DefinitionCollectionListener<V extends object> = (
    name: string,
    newValue: V | undefined,
    collection: DefinitionCollection<V>
) => void;

Package Files (44)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (1)

chokidar

Badge

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

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

Markdown

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

HTML

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

Updated 5 days ago.
Package analyzed in 9561 ms.
Missing or incorrect documentation? Open an issue for this package.

@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 deepCopy

function dirname

function extname

function fragment

function getSystemPath

function isAbsolute

function isJsonArray

function isJsonObject

function isPromise

function join

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

Deprecated

class DependencyNotFoundException

class FileAlreadyExistException

class FileDoesNotExistException

class InvalidPathException

class InvalidUpdateRecordException

Deprecated

class MergeConflictException

Deprecated

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

Deprecated

class UnknownException