Angular DevKit Core is a comprehensive utility library that serves as the foundational infrastructure for Angular CLI tools and build systems. It provides essential services including JSON schema validation, advanced logging capabilities, virtual filesystem abstractions, workspace configuration management, and shared utilities for error handling and data manipulation across the Angular DevKit ecosystem.
npm install @angular-devkit/coreMain entry point:
import { json, logging, workspaces } from "@angular-devkit/core";
import {
BaseException,
FileDoesNotExistException,
Path,
normalize,
virtualFs
} from "@angular-devkit/core";Node.js specific functionality:
import { NodeJsSyncHost, createConsoleLogger } from "@angular-devkit/core/node";Node.js testing utilities:
import { TempScopedNodeJsSyncHost } from "@angular-devkit/core/node/testing";CommonJS:
const { json, logging, workspaces, normalize, virtualFs } = require("@angular-devkit/core");
const { NodeJsSyncHost, createConsoleLogger } = require("@angular-devkit/core/node");import {
json,
logging,
workspaces,
normalize,
virtualFs
} from "@angular-devkit/core";
import { NodeJsSyncHost } from "@angular-devkit/core/node";
// JSON Schema validation
const registry = new json.schema.CoreSchemaRegistry();
const validator = await registry.compile(mySchema).toPromise();
const result = await validator(data).toPromise();
// Virtual file system operations
const host = new NodeJsSyncHost();
const path = normalize('/my/file.txt');
const content = await host.read(path).toPromise();
// Workspace management
const workspaceHost = workspaces.createWorkspaceHost(host);
const { workspace } = await workspaces.readWorkspace('/path/to/workspace/', workspaceHost);
// Logging
const logger = new logging.Logger('my-logger');
logger.info('Operation completed successfully');Angular DevKit Core is organized into several key modules:
Comprehensive JSON processing and schema validation system built on AJV, providing type-safe validation, format checking, and schema compilation with support for custom validators and smart defaults.
namespace json {
type JsonValue = boolean | string | number | JsonArray | JsonObject | null;
interface JsonObject { [key: string]: JsonValue; }
interface JsonArray extends Array<JsonValue> {}
function isJsonObject(value: unknown): value is JsonObject;
function isJsonArray(value: unknown): value is JsonArray;
namespace schema {
interface SchemaRegistry {
compile(schema: Object): Observable<SchemaValidator>;
addFormat(name: string, formatter: SchemaFormatter): void;
}
class CoreSchemaRegistry implements SchemaRegistry {
constructor(formats?: { [name: string]: SchemaFormatter });
}
}
}Abstract file system API with path management utilities and multiple host implementations, enabling consistent file operations across different environments including memory, Node.js, and testing scenarios.
type Path = string & { __PRIVATE_DEVKIT_PATH: void };
type PathFragment = string & { __PRIVATE_DEVKIT_PATH_FRAGMENT: void };
function normalize(path: string): Path;
function join(p1: Path, ...others: PathFragment[]): Path;
function dirname(path: Path): Path;
function basename(path: Path, ext?: string): PathFragment;
namespace virtualFs {
interface Host<StatsT extends object = {}> {
capabilities: HostCapabilities;
read(path: Path): Observable<FileBuffer>;
write(path: Path, content: FileBufferLike): Observable<void>;
delete(path: Path): Observable<void>;
rename(from: Path, to: Path): Observable<void>;
list(path: Path): Observable<PathFragment[]>;
exists(path: Path): Observable<boolean>;
isDirectory(path: Path): Observable<boolean>;
isFile(path: Path): Observable<boolean>;
stat(path: Path): Observable<Stats<StatsT>>;
watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent>;
}
}Structured logging infrastructure with multiple logger implementations, level filtering, message transformation, and Observable-based event streaming for comprehensive application monitoring.
namespace logging {
type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
interface LogEntry {
level: LogLevel;
message: string;
timestamp: Date;
metadata: JsonObject;
}
class Logger extends Observable<LogEntry> {
constructor(name: string, parent?: Logger);
debug(message: string, metadata?: JsonObject): void;
info(message: string, metadata?: JsonObject): void;
warn(message: string, metadata?: JsonObject): void;
error(message: string, metadata?: JsonObject): void;
fatal(message: string, metadata?: JsonObject): void;
createChild(name: string): Logger;
}
}Collection of utility functions for string processing, templating, data structures, and object manipulation, including case conversion, template parsing, priority queues, and deep copying capabilities.
function deepCopy<T>(value: T): T;
function template<T = {}>(content: string, options?: TemplateOptions): (context: T) => string;
namespace strings {
function camelize(str: string): string;
function classify(str: string): string;
function dasherize(str: string): string;
function decamelize(str: string): string;
function underscore(str: string): string;
function capitalize(str: string): string;
function levenshtein(a: string, b: string): number;
}
namespace tags {
function oneLine(strings: TemplateStringsArray, ...values: any[]): string;
function stripIndent(strings: TemplateStringsArray, ...values: any[]): string;
function indentBy(spaces: number): TemplateTag;
}Angular workspace definition system for reading, writing, and manipulating Angular CLI workspace configurations with support for projects, targets, and extensions.
namespace workspaces {
interface WorkspaceDefinition {
readonly extensions: Record<string, JsonValue | undefined>;
readonly projects: ProjectDefinitionCollection;
}
interface ProjectDefinition {
readonly extensions: Record<string, JsonValue | undefined>;
readonly targets: TargetDefinitionCollection;
root: string;
prefix?: string;
sourceRoot?: string;
}
function readWorkspace(
path: string,
host: WorkspaceHost,
format?: WorkspaceFormat
): Promise<{ workspace: WorkspaceDefinition }>;
function writeWorkspace(
workspace: WorkspaceDefinition,
host: WorkspaceHost,
path?: string,
format?: WorkspaceFormat
): Promise<void>;
}Node.js specific implementations including file system hosts and console logging capabilities, plus testing utilities for creating temporary file systems in test environments.
class NodeJsSyncHost implements virtualFs.Host<fs.Stats> {
readonly capabilities: HostCapabilities;
read(path: Path): Observable<FileBuffer>;
write(path: Path, content: FileBufferLike): Observable<void>;
// ... other Host methods
}
function createConsoleLogger(verbose?: boolean, stdout?: ProcessOutput, stderr?: ProcessOutput): logging.Logger;
// Testing utilities
class TempScopedNodeJsSyncHost extends virtualFs.ScopedHost<fs.Stats> {
get files(): Path[];
get root(): Path;
get sync(): virtualFs.SyncDelegateHost<fs.Stats>;
}The package provides a comprehensive exception hierarchy for handling various error conditions:
class BaseException extends Error {
constructor(message?: string);
}
class UnknownException extends BaseException {}
class FileDoesNotExistException extends BaseException {}
class FileAlreadyExistException extends BaseException {}
class PathIsDirectoryException extends BaseException {}
class PathIsFileException extends BaseException {}
class InvalidPathException extends BaseException {}
class PathMustBeAbsoluteException extends BaseException {}
class PathCannotBeFragmentException extends BaseException {}All exception classes extend the base Error class and provide specific error types for different failure scenarios in file system operations and path manipulation.