@angular-devkit/architect - npm Package Compare versions

Comparing version 0.12.1 to 0.13.0-beta.0

src/architect-legacy.d.ts

+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { BaseException, JsonObject, Path, experimental, logging, virtualFs } from '@angular-devkit/core';
+import { Observable } from 'rxjs';
+/**
+ * @deprecated
+ */
+export declare class ProjectNotFoundException extends BaseException {
+    constructor(projectName: string);
+}
+/**
+ * @deprecated
+ */
+export declare class TargetNotFoundException extends BaseException {
+    constructor(projectName: string, targetName: string);
+}
+/**
+ * @deprecated
+ */
+export declare class ConfigurationNotFoundException extends BaseException {
+    constructor(projectName: string, configurationName: string);
+}
+/**
+ * @deprecated
+ */
+export declare class BuilderCannotBeResolvedException extends BaseException {
+    constructor(builder: string);
+}
+/**
+ * @deprecated
+ */
+export declare class ArchitectNotYetLoadedException extends BaseException {
+    constructor();
+}
+/**
+ * @deprecated
+ */
+export declare class BuilderNotFoundException extends BaseException {
+    constructor(builder: string);
+}
+/**
+ * @deprecated
+ */
+export interface BuilderContext {
+    logger: logging.Logger;
+    host: virtualFs.Host<{}>;
+    workspace: experimental.workspace.Workspace;
+    architect: Architect;
+    targetSpecifier?: TargetSpecifier;
+}
+/**
+ * TODO: use unknown
+ * @deprecated
+ */
+export interface BuildEvent<BuildResultT = any> {
+    success: boolean;
+    result?: BuildResultT;
+}
+/**
+ * @deprecated
+ */
+export interface Builder<OptionsT> {
+    run(builderConfig: BuilderConfiguration<Partial<OptionsT>>): Observable<BuildEvent>;
+}
+/**
+ * @deprecated
+ */
+export interface BuilderPathsMap {
+    builders: {
+        [k: string]: BuilderPaths;
+    };
+}
+/**
+ * @deprecated
+ */
+export interface BuilderPaths {
+    class: Path;
+    schema: Path;
+    description: string;
+}
+/**
+ * @deprecated
+ */
+export interface BuilderDescription {
+    name: string;
+    schema: JsonObject;
+    description: string;
+}
+/**
+ * @deprecated
+ */
+export interface BuilderConstructor<OptionsT> {
+    new (context: BuilderContext): Builder<OptionsT>;
+}
+/**
+ * @deprecated
+ */
+export interface BuilderConfiguration<OptionsT = {}> {
+    root: Path;
+    sourceRoot?: Path;
+    projectType: string;
+    builder: string;
+    options: OptionsT;
+}
+/**
+ * @deprecated
+ */
+export interface TargetSpecifier<OptionsT = {}> {
+    project: string;
+    target: string;
+    configuration?: string;
+    overrides?: Partial<OptionsT>;
+}
+/**
+ * @deprecated
+ */
+export interface TargetMap {
+    [k: string]: Target;
+}
+export declare type TargetOptions<T = JsonObject> = T;
+export declare type TargetConfiguration<T = JsonObject> = Partial<T>;
+/**
+ * @deprecated
+ */
+export interface Target<T = JsonObject> {
+    builder: string;
+    options: TargetOptions<T>;
+    configurations?: {
+        [k: string]: TargetConfiguration<T>;
+    };
+}
+/**
+ * @deprecated
+ */
+export declare class Architect {
+    private _workspace;
+    private readonly _targetsSchemaPath;
+    private readonly _buildersSchemaPath;
+    private _targetsSchema;
+    private _buildersSchema;
+    private _architectSchemasLoaded;
+    private _targetMapMap;
+    private _builderPathsMap;
+    private _builderDescriptionMap;
+    private _builderConstructorMap;
+    constructor(_workspace: experimental.workspace.Workspace);
+    loadArchitect(): Observable<this>;
+    listProjectTargets(projectName: string): string[];
+    private _getProjectTargetMap;
+    private _getProjectTarget;
+    getBuilderConfiguration<OptionsT>(targetSpec: TargetSpecifier): BuilderConfiguration<OptionsT>;
+    run<OptionsT>(builderConfig: BuilderConfiguration<OptionsT>, partialContext?: Partial<BuilderContext>): Observable<BuildEvent>;
+    getBuilderDescription<OptionsT>(builderConfig: BuilderConfiguration<OptionsT>): Observable<BuilderDescription>;
+    validateBuilderOptions<OptionsT>(builderConfig: BuilderConfiguration<OptionsT>, builderDescription: BuilderDescription): Observable<BuilderConfiguration<OptionsT>>;
+    getBuilder<OptionsT>(builderDescription: BuilderDescription, context: BuilderContext): Builder<OptionsT>;
+    private _loadJsonFile;
+}

src/architect-legacy.js

+"use strict";
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@angular-devkit/core");
+const node_1 = require("@angular-devkit/core/node");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+/**
+ * @deprecated
+ */
+class ProjectNotFoundException extends core_1.BaseException {
+    constructor(projectName) {
+        super(`Project '${projectName}' could not be found in Workspace.`);
+    }
+}
+exports.ProjectNotFoundException = ProjectNotFoundException;
+/**
+ * @deprecated
+ */
+class TargetNotFoundException extends core_1.BaseException {
+    constructor(projectName, targetName) {
+        super(`Target '${targetName}' could not be found in project '${projectName}'.`);
+    }
+}
+exports.TargetNotFoundException = TargetNotFoundException;
+/**
+ * @deprecated
+ */
+class ConfigurationNotFoundException extends core_1.BaseException {
+    constructor(projectName, configurationName) {
+        super(`Configuration '${configurationName}' could not be found in project '${projectName}'.`);
+    }
+}
+exports.ConfigurationNotFoundException = ConfigurationNotFoundException;
+// TODO: break this exception apart into more granular ones.
+/**
+ * @deprecated
+ */
+class BuilderCannotBeResolvedException extends core_1.BaseException {
+    constructor(builder) {
+        super(`Builder '${builder}' cannot be resolved.`);
+    }
+}
+exports.BuilderCannotBeResolvedException = BuilderCannotBeResolvedException;
+/**
+ * @deprecated
+ */
+class ArchitectNotYetLoadedException extends core_1.BaseException {
+    constructor() { super(`Architect needs to be loaded before Architect is used.`); }
+}
+exports.ArchitectNotYetLoadedException = ArchitectNotYetLoadedException;
+/**
+ * @deprecated
+ */
+class BuilderNotFoundException extends core_1.BaseException {
+    constructor(builder) {
+        super(`Builder ${builder} could not be found.`);
+    }
+}
+exports.BuilderNotFoundException = BuilderNotFoundException;
+/**
+ * @deprecated
+ */
+class Architect {
+    constructor(_workspace) {
+        this._workspace = _workspace;
+        this._targetsSchemaPath = core_1.join(core_1.normalize(__dirname), 'targets-schema.json');
+        this._buildersSchemaPath = core_1.join(core_1.normalize(__dirname), 'builders-schema.json');
+        this._architectSchemasLoaded = false;
+        this._targetMapMap = new Map();
+        this._builderPathsMap = new Map();
+        this._builderDescriptionMap = new Map();
+        this._builderConstructorMap = new Map();
+    }
+    loadArchitect() {
+        if (this._architectSchemasLoaded) {
+            return rxjs_1.of(this);
+        }
+        else {
+            return rxjs_1.forkJoin(this._loadJsonFile(this._targetsSchemaPath), this._loadJsonFile(this._buildersSchemaPath)).pipe(operators_1.concatMap(([targetsSchema, buildersSchema]) => {
+                this._targetsSchema = targetsSchema;
+                this._buildersSchema = buildersSchema;
+                this._architectSchemasLoaded = true;
+                // Validate and cache all project target maps.
+                return rxjs_1.forkJoin(...this._workspace.listProjectNames().map(projectName => {
+                    const unvalidatedTargetMap = this._workspace.getProjectTargets(projectName);
+                    return this._workspace.validateAgainstSchema(unvalidatedTargetMap, this._targetsSchema).pipe(operators_1.tap(targetMap => this._targetMapMap.set(projectName, targetMap)));
+                }));
+            }), operators_1.map(() => this));
+        }
+    }
+    listProjectTargets(projectName) {
+        return Object.keys(this._getProjectTargetMap(projectName));
+    }
+    _getProjectTargetMap(projectName) {
+        if (!this._targetMapMap.has(projectName)) {
+            throw new ProjectNotFoundException(projectName);
+        }
+        return this._targetMapMap.get(projectName);
+    }
+    _getProjectTarget(projectName, targetName) {
+        const targetMap = this._getProjectTargetMap(projectName);
+        const target = targetMap[targetName];
+        if (!target) {
+            throw new TargetNotFoundException(projectName, targetName);
+        }
+        return target;
+    }
+    getBuilderConfiguration(targetSpec) {
+        const { project: projectName, target: targetName, configuration: configurationName, overrides, } = targetSpec;
+        const project = this._workspace.getProject(projectName);
+        const target = this._getProjectTarget(projectName, targetName);
+        const options = target.options;
+        let configuration = {};
+        if (configurationName) {
+            if (!target.configurations) {
+                throw new ConfigurationNotFoundException(projectName, configurationName);
+            }
+            configuration = target.configurations[configurationName];
+            if (!configuration) {
+                throw new ConfigurationNotFoundException(projectName, configurationName);
+            }
+        }
+        const builderConfiguration = {
+            root: project.root,
+            sourceRoot: project.sourceRoot,
+            projectType: project.projectType,
+            builder: target.builder,
+            options: Object.assign({}, options, configuration, overrides),
+        };
+        return builderConfiguration;
+    }
+    run(builderConfig, partialContext = {}) {
+        const context = Object.assign({ logger: new core_1.logging.NullLogger(), architect: this, host: this._workspace.host, workspace: this._workspace }, partialContext);
+        let builderDescription;
+        return this.getBuilderDescription(builderConfig).pipe(operators_1.tap(description => builderDescription = description), operators_1.concatMap(() => this.validateBuilderOptions(builderConfig, builderDescription)), operators_1.tap(validatedBuilderConfig => builderConfig = validatedBuilderConfig), operators_1.map(() => this.getBuilder(builderDescription, context)), operators_1.concatMap(builder => builder.run(builderConfig)));
+    }
+    getBuilderDescription(builderConfig) {
+        // Check cache for this builder description.
+        if (this._builderDescriptionMap.has(builderConfig.builder)) {
+            return rxjs_1.of(this._builderDescriptionMap.get(builderConfig.builder));
+        }
+        return new rxjs_1.Observable((obs) => {
+            // TODO: this probably needs to be more like NodeModulesEngineHost.
+            const basedir = core_1.getSystemPath(this._workspace.root);
+            const [pkg, builderName] = builderConfig.builder.split(':');
+            const pkgJsonPath = node_1.resolve(pkg, { basedir, resolvePackageJson: true, checkLocal: true });
+            let buildersJsonPath;
+            let builderPaths;
+            // Read the `builders` entry of package.json.
+            return this._loadJsonFile(core_1.normalize(pkgJsonPath)).pipe(operators_1.concatMap((pkgJson) => {
+                const pkgJsonBuildersentry = pkgJson['builders'];
+                if (!pkgJsonBuildersentry) {
+                    return rxjs_1.throwError(new BuilderCannotBeResolvedException(builderConfig.builder));
+                }
+                buildersJsonPath = core_1.join(core_1.dirname(core_1.normalize(pkgJsonPath)), pkgJsonBuildersentry);
+                return this._loadJsonFile(buildersJsonPath);
+            }), 
+            // Validate builders json.
+            operators_1.concatMap((builderPathsMap) => this._workspace.validateAgainstSchema(builderPathsMap, this._buildersSchema)), operators_1.concatMap((builderPathsMap) => {
+                builderPaths = builderPathsMap.builders[builderName];
+                if (!builderPaths) {
+                    return rxjs_1.throwError(new BuilderCannotBeResolvedException(builderConfig.builder));
+                }
+                // Resolve paths in the builder paths.
+                const builderJsonDir = core_1.dirname(buildersJsonPath);
+                builderPaths.schema = core_1.join(builderJsonDir, builderPaths.schema);
+                builderPaths.class = core_1.join(builderJsonDir, builderPaths.class);
+                // Save the builder paths so that we can lazily load the builder.
+                this._builderPathsMap.set(builderConfig.builder, builderPaths);
+                // Load the schema.
+                return this._loadJsonFile(builderPaths.schema);
+            }), operators_1.map(builderSchema => {
+                const builderDescription = {
+                    name: builderConfig.builder,
+                    schema: builderSchema,
+                    description: builderPaths.description,
+                };
+                // Save to cache before returning.
+                this._builderDescriptionMap.set(builderDescription.name, builderDescription);
+                return builderDescription;
+            })).subscribe(obs);
+        });
+    }
+    validateBuilderOptions(builderConfig, builderDescription) {
+        return this._workspace.validateAgainstSchema(builderConfig.options, builderDescription.schema).pipe(operators_1.map(validatedOptions => {
+            builderConfig.options = validatedOptions;
+            return builderConfig;
+        }));
+    }
+    getBuilder(builderDescription, context) {
+        const name = builderDescription.name;
+        let builderConstructor;
+        // Check cache for this builder.
+        if (this._builderConstructorMap.has(name)) {
+            builderConstructor = this._builderConstructorMap.get(name);
+        }
+        else {
+            if (!this._builderPathsMap.has(name)) {
+                throw new BuilderNotFoundException(name);
+            }
+            const builderPaths = this._builderPathsMap.get(name);
+            // TODO: support more than the default export, maybe via builder#import-name.
+            const builderModule = require(core_1.getSystemPath(builderPaths.class));
+            builderConstructor = builderModule['default'];
+            // Save builder to cache before returning.
+            this._builderConstructorMap.set(builderDescription.name, builderConstructor);
+        }
+        const builder = new builderConstructor(context);
+        return builder;
+    }
+    _loadJsonFile(path) {
+        return this._workspace.host.read(core_1.normalize(path)).pipe(operators_1.map(buffer => core_1.virtualFs.fileBufferToString(buffer)), operators_1.map(str => core_1.parseJson(str, core_1.JsonParseMode.Loose)));
+    }
+}
+exports.Architect = Architect;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"architect-legacy.js","sourceRoot":"./","sources":["packages/angular_devkit/architect/src/architect-legacy.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAEH,+CAa8B;AAC9B,oDAAmE;AACnE,+BAA4D;AAC5D,8CAAqD;AAErD;;GAEG;AACH,MAAa,wBAAyB,SAAQ,oBAAa;IACzD,YAAY,WAAmB;QAC7B,KAAK,CAAC,YAAY,WAAW,oCAAoC,CAAC,CAAC;IACrE,CAAC;CACF;AAJD,4DAIC;AAED;;GAEG;AACH,MAAa,uBAAwB,SAAQ,oBAAa;IACxD,YAAY,WAAmB,EAAE,UAAkB;QACjD,KAAK,CAAC,WAAW,UAAU,oCAAoC,WAAW,IAAI,CAAC,CAAC;IAClF,CAAC;CACF;AAJD,0DAIC;AAED;;GAEG;AACH,MAAa,8BAA+B,SAAQ,oBAAa;IAC/D,YAAY,WAAmB,EAAE,iBAAyB;QACxD,KAAK,CAAC,kBAAkB,iBAAiB,oCAAoC,WAAW,IAAI,CAAC,CAAC;IAChG,CAAC;CACF;AAJD,wEAIC;AAED,4DAA4D;AAC5D;;GAEG;AACH,MAAa,gCAAiC,SAAQ,oBAAa;IACjE,YAAY,OAAe;QACzB,KAAK,CAAC,YAAY,OAAO,uBAAuB,CAAC,CAAC;IACpD,CAAC;CACF;AAJD,4EAIC;AAED;;GAEG;AACH,MAAa,8BAA+B,SAAQ,oBAAa;IAC/D,gBAAgB,KAAK,CAAC,wDAAwD,CAAC,CAAC,CAAC,CAAC;CACnF;AAFD,wEAEC;AAED;;GAEG;AACH,MAAa,wBAAyB,SAAQ,oBAAa;IACzD,YAAY,OAAe;QACzB,KAAK,CAAC,WAAW,OAAO,sBAAsB,CAAC,CAAC;IAClD,CAAC;CACF;AAJD,4DAIC;AAwGD;;GAEG;AACH,MAAa,SAAS;IAWpB,YAAoB,UAA4C;QAA5C,eAAU,GAAV,UAAU,CAAkC;QAV/C,uBAAkB,GAAG,WAAI,CAAC,gBAAS,CAAC,SAAS,CAAC,EAAE,qBAAqB,CAAC,CAAC;QACvE,wBAAmB,GAAG,WAAI,CAAC,gBAAS,CAAC,SAAS,CAAC,EAAE,sBAAsB,CAAC,CAAC;QAGlF,4BAAuB,GAAG,KAAK,CAAC;QAChC,kBAAa,GAAG,IAAI,GAAG,EAAqB,CAAC;QAC7C,qBAAgB,GAAG,IAAI,GAAG,EAAwB,CAAC;QACnD,2BAAsB,GAAG,IAAI,GAAG,EAA8B,CAAC;QAC/D,2BAAsB,GAAG,IAAI,GAAG,EAAkC,CAAC;IAEP,CAAC;IAErE,aAAa;QACX,IAAI,IAAI,CAAC,uBAAuB,EAAE;YAChC,OAAO,SAAE,CAAC,IAAI,CAAC,CAAC;SACjB;aAAM;YACL,OAAO,eAAQ,CACb,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAC3C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAC7C,CAAC,IAAI,CACJ,qBAAS,CAAC,CAAC,CAAC,aAAa,EAAE,cAAc,CAAC,EAAE,EAAE;gBAC5C,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;gBACpC,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;gBACtC,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;gBAEpC,8CAA8C;gBAC9C,OAAO,eAAQ,CACb,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE;oBACtD,MAAM,oBAAoB,GAAG,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;oBAE5E,OAAO,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAC1C,oBAAoB,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC,IAAI,CAC7C,eAAG,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC,CACnE,CAAC;gBACJ,CAAC,CAAC,CACH,CAAC;YACJ,CAAC,CAAC,EACF,eAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAChB,CAAC;SACH;IACH,CAAC;IAED,kBAAkB,CAAC,WAAmB;QACpC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC,CAAC;IAC7D,CAAC;IAEO,oBAAoB,CAAC,WAAmB;QAC9C,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE;YACxC,MAAM,IAAI,wBAAwB,CAAC,WAAW,CAAC,CAAC;SACjD;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,WAAW,CAAc,CAAC;IAC1D,CAAC;IAEO,iBAAiB,CAAS,WAAmB,EAAE,UAAkB;QACvE,MAAM,SAAS,GAAG,IAAI,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;QAEzD,MAAM,MAAM,GAAG,SAAS,CAAC,UAAU,CAAoB,CAAC;QAExD,IAAI,CAAC,MAAM,EAAE;YACX,MAAM,IAAI,uBAAuB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;SAC5D;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,uBAAuB,CAAW,UAA2B;QAC3D,MAAM,EACJ,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,iBAAiB,EAChC,SAAS,GACV,GAAG,UAAU,CAAC;QAEf,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;QAC/D,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;QAC/B,IAAI,aAAa,GAAwB,EAAE,CAAC;QAE5C,IAAI,iBAAiB,EAAE;YACrB,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE;gBAC1B,MAAM,IAAI,8BAA8B,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAC;aAC1E;YAED,aAAa,GAAG,MAAM,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;YAEzD,IAAI,CAAC,aAAa,EAAE;gBAClB,MAAM,IAAI,8BAA8B,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAC;aAC1E;SACF;QAED,MAAM,oBAAoB,GAAmC;YAC3D,IAAI,EAAE,OAAO,CAAC,IAAY;YAC1B,UAAU,EAAE,OAAO,CAAC,UAA8B;YAClD,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,OAAO,EAAE,kBACJ,OAAO,EACP,aAAa,EACb,SAAe,CACP;SACd,CAAC;QAEF,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAED,GAAG,CACD,aAA6C,EAC7C,iBAA0C,EAAE;QAE5C,MAAM,OAAO,mBACX,MAAM,EAAE,IAAI,cAAO,CAAC,UAAU,EAAE,EAChC,SAAS,EAAE,IAAI,EACf,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,EAC1B,SAAS,EAAE,IAAI,CAAC,UAAU,IACvB,cAAc,CAClB,CAAC;QAEF,IAAI,kBAAsC,CAAC;QAE3C,OAAO,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC,IAAI,CACnD,eAAG,CAAC,WAAW,CAAC,EAAE,CAAC,kBAAkB,GAAG,WAAW,CAAC,EACpD,qBAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,aAAa,EAAE,kBAAkB,CAAC,CAAC,EAC/E,eAAG,CAAC,sBAAsB,CAAC,EAAE,CAAC,aAAa,GAAG,sBAAsB,CAAC,EACrE,eAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC,EACvD,qBAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CACjD,CAAC;IACJ,CAAC;IAED,qBAAqB,CACnB,aAA6C;QAE7C,4CAA4C;QAC5C,IAAI,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE;YAC1D,OAAO,SAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAuB,CAAC,CAAC;SACzF;QAED,OAAO,IAAI,iBAAU,CAAC,CAAC,GAAG,EAAE,EAAE;YAC5B,mEAAmE;YACnE,MAAM,OAAO,GAAG,oBAAa,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACpD,MAAM,CAAC,GAAG,EAAE,WAAW,CAAC,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC5D,MAAM,WAAW,GAAG,cAAW,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;YAC9F,IAAI,gBAAsB,CAAC;YAC3B,IAAI,YAA0B,CAAC;YAE/B,6CAA6C;YAC7C,OAAO,IAAI,CAAC,aAAa,CAAC,gBAAS,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CACpD,qBAAS,CAAC,CAAC,OAAmB,EAAE,EAAE;gBAChC,MAAM,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAW,CAAC;gBAC3D,IAAI,CAAC,oBAAoB,EAAE;oBACzB,OAAO,iBAAU,CAAC,IAAI,gCAAgC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;iBAChF;gBAED,gBAAgB,GAAG,WAAI,CAAC,cAAO,CAAC,gBAAS,CAAC,WAAW,CAAC,CAAC,EAAE,oBAAoB,CAAC,CAAC;gBAE/E,OAAO,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC;YAC9C,CAAC,CAAC;YACF,0BAA0B;YAC1B,qBAAS,CAAC,CAAC,eAAe,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAClE,eAAe,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,EACzC,qBAAS,CAAC,CAAC,eAAe,EAAE,EAAE;gBAC5B,YAAY,GAAG,eAAe,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;gBAErD,IAAI,CAAC,YAAY,EAAE;oBACjB,OAAO,iBAAU,CAAC,IAAI,gCAAgC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;iBAChF;gBAED,sCAAsC;gBACtC,MAAM,cAAc,GAAG,cAAO,CAAC,gBAAgB,CAAC,CAAC;gBACjD,YAAY,CAAC,MAAM,GAAG,WAAI,CAAC,cAAc,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;gBAChE,YAAY,CAAC,KAAK,GAAG,WAAI,CAAC,cAAc,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;gBAE9D,iEAAiE;gBACjE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;gBAE/D,mBAAmB;gBACnB,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;YACjD,CAAC,CAAC,EACF,eAAG,CAAC,aAAa,CAAC,EAAE;gBAClB,MAAM,kBAAkB,GAAG;oBACzB,IAAI,EAAE,aAAa,CAAC,OAAO;oBAC3B,MAAM,EAAE,aAAa;oBACrB,WAAW,EAAE,YAAY,CAAC,WAAW;iBACtC,CAAC;gBAEF,kCAAkC;gBAClC,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;gBAE7E,OAAO,kBAAkB,CAAC;YAC5B,CAAC,CAAC,CACH,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACnB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sBAAsB,CACpB,aAA6C,EAAE,kBAAsC;QAErF,OAAO,IAAI,CAAC,UAAU,CAAC,qBAAqB,CAC1C,aAAa,CAAC,OAAO,EAAE,kBAAkB,CAAC,MAAM,CACjD,CAAC,IAAI,CACJ,eAAG,CAAC,gBAAgB,CAAC,EAAE;YACrB,aAAa,CAAC,OAAO,GAAG,gBAAgB,CAAC;YAEzC,OAAO,aAAa,CAAC;QACvB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,UAAU,CACR,kBAAsC,EAAE,OAAuB;QAE/D,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,CAAC;QACrC,IAAI,kBAAgD,CAAC;QAErD,gCAAgC;QAChC,IAAI,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YACzC,kBAAkB,GAAG,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,IAAI,CAAiC,CAAC;SAC5F;aAAM;YACL,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;gBACpC,MAAM,IAAI,wBAAwB,CAAC,IAAI,CAAC,CAAC;aAC1C;YAED,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAiB,CAAC;YAErE,6EAA6E;YAC7E,MAAM,aAAa,GAAG,OAAO,CAAC,oBAAa,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;YACjE,kBAAkB,GAAG,aAAa,CAAC,SAAS,CAAiC,CAAC;YAE9E,0CAA0C;YAC1C,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;SAC9E;QAED,MAAM,OAAO,GAAG,IAAI,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAEhD,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,aAAa,CAAC,IAAU;QAC9B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAS,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CACpD,eAAG,CAAC,MAAM,CAAC,EAAE,CAAC,gBAAS,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,EACnD,eAAG,CAAC,GAAG,CAAC,EAAE,CAAC,gBAAS,CAAC,GAAG,EAAE,oBAAa,CAAC,KAAK,CAAqB,CAAC,CACpE,CAAC;IACJ,CAAC;CACF;AApPD,8BAoPC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  BaseException,\n  JsonObject,\n  JsonParseMode,\n  Path,\n  dirname,\n  experimental,\n  getSystemPath,\n  join,\n  logging,\n  normalize,\n  parseJson,\n  virtualFs,\n} from '@angular-devkit/core';\nimport { resolve as nodeResolve } from '@angular-devkit/core/node';\nimport { Observable, forkJoin, of, throwError } from 'rxjs';\nimport { concatMap, map, tap } from 'rxjs/operators';\n\n/**\n * @deprecated\n */\nexport class ProjectNotFoundException extends BaseException {\n  constructor(projectName: string) {\n    super(`Project '${projectName}' could not be found in Workspace.`);\n  }\n}\n\n/**\n * @deprecated\n */\nexport class TargetNotFoundException extends BaseException {\n  constructor(projectName: string, targetName: string) {\n    super(`Target '${targetName}' could not be found in project '${projectName}'.`);\n  }\n}\n\n/**\n * @deprecated\n */\nexport class ConfigurationNotFoundException extends BaseException {\n  constructor(projectName: string, configurationName: string) {\n    super(`Configuration '${configurationName}' could not be found in project '${projectName}'.`);\n  }\n}\n\n// TODO: break this exception apart into more granular ones.\n/**\n * @deprecated\n */\nexport class BuilderCannotBeResolvedException extends BaseException {\n  constructor(builder: string) {\n    super(`Builder '${builder}' cannot be resolved.`);\n  }\n}\n\n/**\n * @deprecated\n */\nexport class ArchitectNotYetLoadedException extends BaseException {\n  constructor() { super(`Architect needs to be loaded before Architect is used.`); }\n}\n\n/**\n * @deprecated\n */\nexport class BuilderNotFoundException extends BaseException {\n  constructor(builder: string) {\n    super(`Builder ${builder} could not be found.`);\n  }\n}\n\n/**\n * @deprecated\n */\nexport interface BuilderContext {\n  logger: logging.Logger;\n  host: virtualFs.Host<{}>;\n  workspace: experimental.workspace.Workspace;\n  architect: Architect;\n  targetSpecifier?: TargetSpecifier;\n}\n\n// TODO: use Build Event Protocol\n// https://docs.bazel.build/versions/master/build-event-protocol.html\n// https://github.com/googleapis/googleapis/tree/master/google/devtools/build/v1\n/**\n * TODO: use unknown\n * @deprecated\n */\nexport interface BuildEvent<BuildResultT = any> {  // tslint:disable-line:no-any\n  success: boolean;\n  result?: BuildResultT;\n}\n\n/**\n * @deprecated\n */\nexport interface Builder<OptionsT> {\n  run(builderConfig: BuilderConfiguration<Partial<OptionsT>>): Observable<BuildEvent>;\n}\n\n/**\n * @deprecated\n */\nexport interface BuilderPathsMap {\n  builders: { [k: string]: BuilderPaths };\n}\n\n/**\n * @deprecated\n */\nexport interface BuilderPaths {\n  class: Path;\n  schema: Path;\n  description: string;\n}\n\n/**\n * @deprecated\n */\nexport interface BuilderDescription {\n  name: string;\n  schema: JsonObject;\n  description: string;\n}\n\n/**\n * @deprecated\n */\nexport interface BuilderConstructor<OptionsT> {\n  new(context: BuilderContext): Builder<OptionsT>;\n}\n\n/**\n * @deprecated\n */\nexport interface BuilderConfiguration<OptionsT = {}> {\n  root: Path;\n  sourceRoot?: Path;\n  projectType: string;\n  builder: string;\n  options: OptionsT;\n}\n\n/**\n * @deprecated\n */\nexport interface TargetSpecifier<OptionsT = {}> {\n  project: string;\n  target: string;\n  configuration?: string;\n  overrides?: Partial<OptionsT>;\n}\n\n/**\n * @deprecated\n */\nexport interface TargetMap {\n  [k: string]: Target;\n}\n\nexport declare type TargetOptions<T = JsonObject> = T;\nexport declare type TargetConfiguration<T = JsonObject> = Partial<T>;\n\n/**\n * @deprecated\n */\nexport interface Target<T = JsonObject> {\n  builder: string;\n  options: TargetOptions<T>;\n  configurations?: { [k: string]: TargetConfiguration<T> };\n}\n\n/**\n * @deprecated\n */\nexport class Architect {\n  private readonly _targetsSchemaPath = join(normalize(__dirname), 'targets-schema.json');\n  private readonly _buildersSchemaPath = join(normalize(__dirname), 'builders-schema.json');\n  private _targetsSchema: JsonObject;\n  private _buildersSchema: JsonObject;\n  private _architectSchemasLoaded = false;\n  private _targetMapMap = new Map<string, TargetMap>();\n  private _builderPathsMap = new Map<string, BuilderPaths>();\n  private _builderDescriptionMap = new Map<string, BuilderDescription>();\n  private _builderConstructorMap = new Map<string, BuilderConstructor<{}>>();\n\n  constructor(private _workspace: experimental.workspace.Workspace) { }\n\n  loadArchitect() {\n    if (this._architectSchemasLoaded) {\n      return of(this);\n    } else {\n      return forkJoin(\n        this._loadJsonFile(this._targetsSchemaPath),\n        this._loadJsonFile(this._buildersSchemaPath),\n      ).pipe(\n        concatMap(([targetsSchema, buildersSchema]) => {\n          this._targetsSchema = targetsSchema;\n          this._buildersSchema = buildersSchema;\n          this._architectSchemasLoaded = true;\n\n          // Validate and cache all project target maps.\n          return forkJoin(\n            ...this._workspace.listProjectNames().map(projectName => {\n              const unvalidatedTargetMap = this._workspace.getProjectTargets(projectName);\n\n              return this._workspace.validateAgainstSchema<TargetMap>(\n                unvalidatedTargetMap, this._targetsSchema).pipe(\n                  tap(targetMap => this._targetMapMap.set(projectName, targetMap)),\n              );\n            }),\n          );\n        }),\n        map(() => this),\n      );\n    }\n  }\n\n  listProjectTargets(projectName: string): string[] {\n    return Object.keys(this._getProjectTargetMap(projectName));\n  }\n\n  private _getProjectTargetMap(projectName: string): TargetMap {\n    if (!this._targetMapMap.has(projectName)) {\n      throw new ProjectNotFoundException(projectName);\n    }\n\n    return this._targetMapMap.get(projectName) as TargetMap;\n  }\n\n  private _getProjectTarget<T = {}>(projectName: string, targetName: string): Target<T> {\n    const targetMap = this._getProjectTargetMap(projectName);\n\n    const target = targetMap[targetName] as {} as Target<T>;\n\n    if (!target) {\n      throw new TargetNotFoundException(projectName, targetName);\n    }\n\n    return target;\n  }\n\n  getBuilderConfiguration<OptionsT>(targetSpec: TargetSpecifier): BuilderConfiguration<OptionsT> {\n    const {\n      project: projectName,\n      target: targetName,\n      configuration: configurationName,\n      overrides,\n    } = targetSpec;\n\n    const project = this._workspace.getProject(projectName);\n    const target = this._getProjectTarget(projectName, targetName);\n    const options = target.options;\n    let configuration: TargetConfiguration = {};\n\n    if (configurationName) {\n      if (!target.configurations) {\n        throw new ConfigurationNotFoundException(projectName, configurationName);\n      }\n\n      configuration = target.configurations[configurationName];\n\n      if (!configuration) {\n        throw new ConfigurationNotFoundException(projectName, configurationName);\n      }\n    }\n\n    const builderConfiguration: BuilderConfiguration<OptionsT> = {\n      root: project.root as Path,\n      sourceRoot: project.sourceRoot as Path | undefined,\n      projectType: project.projectType,\n      builder: target.builder,\n      options: {\n        ...options,\n        ...configuration,\n        ...overrides as {},\n      } as OptionsT,\n    };\n\n    return builderConfiguration;\n  }\n\n  run<OptionsT>(\n    builderConfig: BuilderConfiguration<OptionsT>,\n    partialContext: Partial<BuilderContext> = {},\n  ): Observable<BuildEvent> {\n    const context: BuilderContext = {\n      logger: new logging.NullLogger(),\n      architect: this,\n      host: this._workspace.host,\n      workspace: this._workspace,\n      ...partialContext,\n    };\n\n    let builderDescription: BuilderDescription;\n\n    return this.getBuilderDescription(builderConfig).pipe(\n      tap(description => builderDescription = description),\n      concatMap(() => this.validateBuilderOptions(builderConfig, builderDescription)),\n      tap(validatedBuilderConfig => builderConfig = validatedBuilderConfig),\n      map(() => this.getBuilder(builderDescription, context)),\n      concatMap(builder => builder.run(builderConfig)),\n    );\n  }\n\n  getBuilderDescription<OptionsT>(\n    builderConfig: BuilderConfiguration<OptionsT>,\n  ): Observable<BuilderDescription> {\n    // Check cache for this builder description.\n    if (this._builderDescriptionMap.has(builderConfig.builder)) {\n      return of(this._builderDescriptionMap.get(builderConfig.builder) as BuilderDescription);\n    }\n\n    return new Observable((obs) => {\n      // TODO: this probably needs to be more like NodeModulesEngineHost.\n      const basedir = getSystemPath(this._workspace.root);\n      const [pkg, builderName] = builderConfig.builder.split(':');\n      const pkgJsonPath = nodeResolve(pkg, { basedir, resolvePackageJson: true, checkLocal: true });\n      let buildersJsonPath: Path;\n      let builderPaths: BuilderPaths;\n\n      // Read the `builders` entry of package.json.\n      return this._loadJsonFile(normalize(pkgJsonPath)).pipe(\n        concatMap((pkgJson: JsonObject) => {\n          const pkgJsonBuildersentry = pkgJson['builders'] as string;\n          if (!pkgJsonBuildersentry) {\n            return throwError(new BuilderCannotBeResolvedException(builderConfig.builder));\n          }\n\n          buildersJsonPath = join(dirname(normalize(pkgJsonPath)), pkgJsonBuildersentry);\n\n          return this._loadJsonFile(buildersJsonPath);\n        }),\n        // Validate builders json.\n        concatMap((builderPathsMap) => this._workspace.validateAgainstSchema<BuilderPathsMap>(\n          builderPathsMap, this._buildersSchema)),\n        concatMap((builderPathsMap) => {\n          builderPaths = builderPathsMap.builders[builderName];\n\n          if (!builderPaths) {\n            return throwError(new BuilderCannotBeResolvedException(builderConfig.builder));\n          }\n\n          // Resolve paths in the builder paths.\n          const builderJsonDir = dirname(buildersJsonPath);\n          builderPaths.schema = join(builderJsonDir, builderPaths.schema);\n          builderPaths.class = join(builderJsonDir, builderPaths.class);\n\n          // Save the builder paths so that we can lazily load the builder.\n          this._builderPathsMap.set(builderConfig.builder, builderPaths);\n\n          // Load the schema.\n          return this._loadJsonFile(builderPaths.schema);\n        }),\n        map(builderSchema => {\n          const builderDescription = {\n            name: builderConfig.builder,\n            schema: builderSchema,\n            description: builderPaths.description,\n          };\n\n          // Save to cache before returning.\n          this._builderDescriptionMap.set(builderDescription.name, builderDescription);\n\n          return builderDescription;\n        }),\n      ).subscribe(obs);\n    });\n  }\n\n  validateBuilderOptions<OptionsT>(\n    builderConfig: BuilderConfiguration<OptionsT>, builderDescription: BuilderDescription,\n  ): Observable<BuilderConfiguration<OptionsT>> {\n    return this._workspace.validateAgainstSchema<OptionsT>(\n      builderConfig.options, builderDescription.schema,\n    ).pipe(\n      map(validatedOptions => {\n        builderConfig.options = validatedOptions;\n\n        return builderConfig;\n      }),\n    );\n  }\n\n  getBuilder<OptionsT>(\n    builderDescription: BuilderDescription, context: BuilderContext,\n  ): Builder<OptionsT> {\n    const name = builderDescription.name;\n    let builderConstructor: BuilderConstructor<OptionsT>;\n\n    // Check cache for this builder.\n    if (this._builderConstructorMap.has(name)) {\n      builderConstructor = this._builderConstructorMap.get(name) as BuilderConstructor<OptionsT>;\n    } else {\n      if (!this._builderPathsMap.has(name)) {\n        throw new BuilderNotFoundException(name);\n      }\n\n      const builderPaths = this._builderPathsMap.get(name) as BuilderPaths;\n\n      // TODO: support more than the default export, maybe via builder#import-name.\n      const builderModule = require(getSystemPath(builderPaths.class));\n      builderConstructor = builderModule['default'] as BuilderConstructor<OptionsT>;\n\n      // Save builder to cache before returning.\n      this._builderConstructorMap.set(builderDescription.name, builderConstructor);\n    }\n\n    const builder = new builderConstructor(context);\n\n    return builder;\n  }\n\n  private _loadJsonFile(path: Path): Observable<JsonObject> {\n    return this._workspace.host.read(normalize(path)).pipe(\n      map(buffer => virtualFs.fileBufferToString(buffer)),\n      map(str => parseJson(str, JsonParseMode.Loose) as {} as JsonObject),\n    );\n  }\n}\n"]}

package.json

 {
   "name": "@angular-devkit/architect",
-  "version": "0.12.1",
+  "version": "0.13.0-beta.0",
   "description": "Angular Build Facade",
@@ -8,3 +8,3 @@ "main": "src/index.js",
   "dependencies": {
-    "@angular-devkit/core": "7.2.1",
+    "@angular-devkit/core": "7.3.0-beta.0",
     "rxjs": "6.3.3"
@@ -11,0 +11,0 @@ },

src/index.d.ts

@@ -8,2 +8,5 @@ /**
  */
-export * from './architect';
+/**
+ * @deprecated
+ */
+export * from './architect-legacy';

src/index.js

 "use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
@@ -9,7 +13,6 @@ * @license
  */
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./architect"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiLi8iLCJzb3VyY2VzIjpbInBhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2FyY2hpdGVjdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7R0FNRzs7Ozs7QUFFSCxpQ0FBNEIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vYXJjaGl0ZWN0JztcbiJdfQ==
+/**
+ * @deprecated
+ */
+__export(require("./architect-legacy"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiLi8iLCJzb3VyY2VzIjpbInBhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2FyY2hpdGVjdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTs7Ozs7O0dBTUc7QUFDSDs7R0FFRztBQUNILHdDQUFtQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbi8qKlxuICogQGRlcHJlY2F0ZWRcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9hcmNoaXRlY3QtbGVnYWN5JztcbiJdfQ==

testing/request.d.ts

@@ -0,1 +1,4 @@
+/**
+ * @deprecated
+ */
 export declare function request(url: string, headers?: {}): Promise<string>;

testing/request.js

@@ -13,2 +13,5 @@ "use strict";
 const Url = require("url");
+/**
+ * @deprecated
+ */
 function request(url, headers = {}) {
@@ -60,2 +63,2 @@ return new Promise((resolve, reject) => {
 exports.request = request;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

testing/run-target-spec.d.ts

@@ -12,3 +12,9 @@ /**
 import { TestProjectHost } from './test-project-host';
+/**
+ * @deprecated
+ */
 export declare const DefaultTimeout = 45000;
+/**
+ * @deprecated
+ */
 export declare function runTargetSpec(host: TestProjectHost, targetSpec: TargetSpecifier, overrides?: {}, timeout?: number, logger?: logging.Logger): Observable<BuildEvent>;

testing/run-target-spec.js

@@ -14,3 +14,9 @@ "use strict";
 const src_1 = require("../src");
+/**
+ * @deprecated
+ */
 exports.DefaultTimeout = 45000;
+/**
+ * @deprecated
+ */
 function runTargetSpec(host, targetSpec, overrides = {}, timeout = exports.DefaultTimeout, logger = new core_1.logging.NullLogger()) {
@@ -37,2 +43,2 @@ targetSpec = Object.assign({}, targetSpec, { overrides });
 exports.runTargetSpec = runTargetSpec;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

testing/test-logger.d.ts

@@ -9,2 +9,5 @@ /**
 import { logging } from '@angular-devkit/core';
+/**
+ * @deprecated
+ */
 export declare class TestLogger extends logging.Logger {
@@ -11,0 +14,0 @@ private _latestEntries;

testing/test-logger.js

@@ -11,2 +11,5 @@ "use strict";
 const core_1 = require("@angular-devkit/core");
+/**
+ * @deprecated
+ */
 class TestLogger extends core_1.logging.Logger {
@@ -29,2 +32,2 @@ constructor(name, parent = null) {
 exports.TestLogger = TestLogger;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1sb2dnZXIuanMiLCJzb3VyY2VSb290IjoiLi8iLCJzb3VyY2VzIjpbInBhY2thZ2VzL2FuZ3VsYXJfZGV2a2l0L2FyY2hpdGVjdC90ZXN0aW5nL3Rlc3QtbG9nZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7O0dBTUc7O0FBRUgsK0NBQStDO0FBRy9DOztHQUVHO0FBQ0gsTUFBYSxVQUFXLFNBQVEsY0FBTyxDQUFDLE1BQU07SUFFNUMsWUFBWSxJQUFZLEVBQUUsU0FBZ0MsSUFBSTtRQUM1RCxLQUFLLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBRmQsbUJBQWMsR0FBdUIsRUFBRSxDQUFDO1FBRzlDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDN0QsQ0FBQztJQUVELEtBQUs7UUFDSCxJQUFJLENBQUMsY0FBYyxHQUFHLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQsUUFBUSxDQUFDLE9BQWU7UUFDdEIsT0FBTyxJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUM5RSxDQUFDO0lBRUQsSUFBSSxDQUFDLEVBQVU7UUFDYixPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7Q0FDRjtBQWxCRCxnQ0FrQkMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7IGxvZ2dpbmcgfSBmcm9tICdAYW5ndWxhci1kZXZraXQvY29yZSc7XG5cblxuLyoqXG4gKiBAZGVwcmVjYXRlZFxuICovXG5leHBvcnQgY2xhc3MgVGVzdExvZ2dlciBleHRlbmRzIGxvZ2dpbmcuTG9nZ2VyIHtcbiAgcHJpdmF0ZSBfbGF0ZXN0RW50cmllczogbG9nZ2luZy5Mb2dFbnRyeVtdID0gW107XG4gIGNvbnN0cnVjdG9yKG5hbWU6IHN0cmluZywgcGFyZW50OiBsb2dnaW5nLkxvZ2dlciB8IG51bGwgPSBudWxsKSB7XG4gICAgc3VwZXIobmFtZSwgcGFyZW50KTtcbiAgICB0aGlzLnN1YnNjcmliZSgoZW50cnkpID0+IHRoaXMuX2xhdGVzdEVudHJpZXMucHVzaChlbnRyeSkpO1xuICB9XG5cbiAgY2xlYXIoKSB7XG4gICAgdGhpcy5fbGF0ZXN0RW50cmllcyA9IFtdO1xuICB9XG5cbiAgaW5jbHVkZXMobWVzc2FnZTogc3RyaW5nKSB7XG4gICAgcmV0dXJuIHRoaXMuX2xhdGVzdEVudHJpZXMuc29tZSgoZW50cnkpID0+IGVudHJ5Lm1lc3NhZ2UuaW5jbHVkZXMobWVzc2FnZSkpO1xuICB9XG5cbiAgdGVzdChyZTogUmVnRXhwKSB7XG4gICAgcmV0dXJuIHRoaXMuX2xhdGVzdEVudHJpZXMuc29tZSgoZW50cnkpID0+IHJlLnRlc3QoZW50cnkubWVzc2FnZSkpO1xuICB9XG59XG4iXX0=

testing/test-project-host.d.ts

@@ -13,2 +13,5 @@ /**
 import { Observable } from 'rxjs';
+/**
+ * @deprecated
+ */
 export declare class TestProjectHost extends NodeJsSyncHost {
@@ -15,0 +18,0 @@ protected _templateRoot: Path;

testing/test-project-host.js

@@ -14,2 +14,5 @@ "use strict";
 const operators_1 = require("rxjs/operators");
+/**
+ * @deprecated
+ */
 class TestProjectHost extends node_1.NodeJsSyncHost {
@@ -105,2 +108,2 @@ constructor(_templateRoot) {
 exports.TestProjectHost = TestProjectHost;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-project-host.js","sourceRoot":"./","sources":["packages/angular_devkit/architect/testing/test-project-host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  Path,\n  PathFragment,\n  basename,\n  dirname,\n  join,\n  normalize,\n  relative,\n  virtualFs,\n} from '@angular-devkit/core';\nimport { NodeJsSyncHost } from '@angular-devkit/core/node';\nimport { Stats } from 'fs';\nimport { EMPTY, Observable, from, of } from 'rxjs';\nimport { concatMap, delay, finalize, map, mergeMap, retry, tap } from 'rxjs/operators';\n\n\nexport class TestProjectHost extends NodeJsSyncHost {\n  private _currentRoot: Path | null = null;\n  private _scopedSyncHost: virtualFs.SyncDelegateHost<Stats> | null = null;\n\n  constructor(protected _templateRoot: Path) {\n    super();\n  }\n\n  root(): Path {\n    if (this._currentRoot === null) {\n      throw new Error('TestProjectHost must be initialized before being used.');\n    }\n\n    return this._currentRoot;\n  }\n\n  scopedSync(): virtualFs.SyncDelegateHost<Stats> {\n    if (this._currentRoot === null || this._scopedSyncHost === null) {\n      throw new Error('TestProjectHost must be initialized before being used.');\n    }\n\n    return this._scopedSyncHost;\n  }\n\n  initialize(): Observable<void> {\n    const recursiveList = (path: Path): Observable<Path> => this.list(path).pipe(\n      // Emit each fragment individually.\n      concatMap(fragments => from(fragments)),\n      // Join the path with fragment.\n      map(fragment => join(path, fragment)),\n      // Emit directory content paths instead of the directory path.\n      mergeMap(path => this.isDirectory(path).pipe(\n        concatMap(isDir => isDir ? recursiveList(path) : of(path)),\n      )),\n    );\n\n    // Find a unique folder that we can write to to use as current root.\n    return this.findUniqueFolderPath().pipe(\n      // Save the path and create a scoped host for it.\n      tap(newFolderPath => {\n        this._currentRoot = newFolderPath;\n        this._scopedSyncHost = new virtualFs.SyncDelegateHost(\n          new virtualFs.ScopedHost(this, this.root()));\n      }),\n      // List all files in root.\n      concatMap(() => recursiveList(this._templateRoot)),\n      // Copy them over to the current root.\n      concatMap(from => {\n        const to = join(this.root(), relative(this._templateRoot, from));\n\n        return this.read(from).pipe(\n          concatMap(buffer => this.write(to, buffer)),\n        );\n      }),\n      map(() => { }),\n    );\n  }\n\n  restore(): Observable<void> {\n    if (this._currentRoot === null) {\n      return EMPTY;\n    }\n\n    // Delete the current root and clear the variables.\n    // Wait 50ms and retry up to 10 times, to give time for file locks to clear.\n    return this.exists(this.root()).pipe(\n      delay(50),\n      concatMap(exists => exists ? this.delete(this.root()) : EMPTY),\n      retry(10),\n      finalize(() => {\n        this._currentRoot = null;\n        this._scopedSyncHost = null;\n      }),\n    );\n  }\n\n  writeMultipleFiles(files: { [path: string]: string | ArrayBufferLike | Buffer }): void {\n    Object.keys(files).forEach(fileName => {\n      let content = files[fileName];\n      if (typeof content == 'string') {\n        content = virtualFs.stringToFileBuffer(content);\n      } else if (content instanceof Buffer) {\n        content = content.buffer.slice(\n          content.byteOffset,\n          content.byteOffset + content.byteLength,\n        );\n      }\n\n      this.scopedSync().write(\n        normalize(fileName),\n        content,\n      );\n    });\n  }\n\n  replaceInFile(path: string, match: RegExp | string, replacement: string) {\n    const content = virtualFs.fileBufferToString(this.scopedSync().read(normalize(path)));\n    this.scopedSync().write(normalize(path),\n      virtualFs.stringToFileBuffer(content.replace(match, replacement)));\n  }\n\n  appendToFile(path: string, str: string) {\n    const content = virtualFs.fileBufferToString(this.scopedSync().read(normalize(path)));\n    this.scopedSync().write(normalize(path),\n      virtualFs.stringToFileBuffer(content.concat(str)));\n  }\n\n  fileMatchExists(dir: string, regex: RegExp): PathFragment | undefined {\n    const [fileName] = this.scopedSync().list(normalize(dir)).filter(name => name.match(regex));\n\n    return fileName || undefined;\n  }\n\n  copyFile(from: string, to: string) {\n    const content = this.scopedSync().read(normalize(from));\n    this.scopedSync().write(normalize(to), content);\n  }\n\n  private findUniqueFolderPath(): Observable<Path> {\n    // 11 character alphanumeric string.\n    const randomString = Math.random().toString(36).slice(2);\n    const newFolderName = `test-project-host-${basename(this._templateRoot)}-${randomString}`;\n    const newFolderPath = join(dirname(this._templateRoot), newFolderName);\n\n    return this.exists(newFolderPath).pipe(\n      concatMap(exists => exists ? this.findUniqueFolderPath() : of(newFolderPath)),\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-project-host.js","sourceRoot":"./","sources":["packages/angular_devkit/architect/testing/test-project-host.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  Path,\n  PathFragment,\n  basename,\n  dirname,\n  join,\n  normalize,\n  relative,\n  virtualFs,\n} from '@angular-devkit/core';\nimport { NodeJsSyncHost } from '@angular-devkit/core/node';\nimport { Stats } from 'fs';\nimport { EMPTY, Observable, from, of } from 'rxjs';\nimport { concatMap, delay, finalize, map, mergeMap, retry, tap } from 'rxjs/operators';\n\n\n/**\n * @deprecated\n */\nexport class TestProjectHost extends NodeJsSyncHost {\n  private _currentRoot: Path | null = null;\n  private _scopedSyncHost: virtualFs.SyncDelegateHost<Stats> | null = null;\n\n  constructor(protected _templateRoot: Path) {\n    super();\n  }\n\n  root(): Path {\n    if (this._currentRoot === null) {\n      throw new Error('TestProjectHost must be initialized before being used.');\n    }\n\n    return this._currentRoot;\n  }\n\n  scopedSync(): virtualFs.SyncDelegateHost<Stats> {\n    if (this._currentRoot === null || this._scopedSyncHost === null) {\n      throw new Error('TestProjectHost must be initialized before being used.');\n    }\n\n    return this._scopedSyncHost;\n  }\n\n  initialize(): Observable<void> {\n    const recursiveList = (path: Path): Observable<Path> => this.list(path).pipe(\n      // Emit each fragment individually.\n      concatMap(fragments => from(fragments)),\n      // Join the path with fragment.\n      map(fragment => join(path, fragment)),\n      // Emit directory content paths instead of the directory path.\n      mergeMap(path => this.isDirectory(path).pipe(\n        concatMap(isDir => isDir ? recursiveList(path) : of(path)),\n      )),\n    );\n\n    // Find a unique folder that we can write to to use as current root.\n    return this.findUniqueFolderPath().pipe(\n      // Save the path and create a scoped host for it.\n      tap(newFolderPath => {\n        this._currentRoot = newFolderPath;\n        this._scopedSyncHost = new virtualFs.SyncDelegateHost(\n          new virtualFs.ScopedHost(this, this.root()));\n      }),\n      // List all files in root.\n      concatMap(() => recursiveList(this._templateRoot)),\n      // Copy them over to the current root.\n      concatMap(from => {\n        const to = join(this.root(), relative(this._templateRoot, from));\n\n        return this.read(from).pipe(\n          concatMap(buffer => this.write(to, buffer)),\n        );\n      }),\n      map(() => { }),\n    );\n  }\n\n  restore(): Observable<void> {\n    if (this._currentRoot === null) {\n      return EMPTY;\n    }\n\n    // Delete the current root and clear the variables.\n    // Wait 50ms and retry up to 10 times, to give time for file locks to clear.\n    return this.exists(this.root()).pipe(\n      delay(50),\n      concatMap(exists => exists ? this.delete(this.root()) : EMPTY),\n      retry(10),\n      finalize(() => {\n        this._currentRoot = null;\n        this._scopedSyncHost = null;\n      }),\n    );\n  }\n\n  writeMultipleFiles(files: { [path: string]: string | ArrayBufferLike | Buffer }): void {\n    Object.keys(files).forEach(fileName => {\n      let content = files[fileName];\n      if (typeof content == 'string') {\n        content = virtualFs.stringToFileBuffer(content);\n      } else if (content instanceof Buffer) {\n        content = content.buffer.slice(\n          content.byteOffset,\n          content.byteOffset + content.byteLength,\n        );\n      }\n\n      this.scopedSync().write(\n        normalize(fileName),\n        content,\n      );\n    });\n  }\n\n  replaceInFile(path: string, match: RegExp | string, replacement: string) {\n    const content = virtualFs.fileBufferToString(this.scopedSync().read(normalize(path)));\n    this.scopedSync().write(normalize(path),\n      virtualFs.stringToFileBuffer(content.replace(match, replacement)));\n  }\n\n  appendToFile(path: string, str: string) {\n    const content = virtualFs.fileBufferToString(this.scopedSync().read(normalize(path)));\n    this.scopedSync().write(normalize(path),\n      virtualFs.stringToFileBuffer(content.concat(str)));\n  }\n\n  fileMatchExists(dir: string, regex: RegExp): PathFragment | undefined {\n    const [fileName] = this.scopedSync().list(normalize(dir)).filter(name => name.match(regex));\n\n    return fileName || undefined;\n  }\n\n  copyFile(from: string, to: string) {\n    const content = this.scopedSync().read(normalize(from));\n    this.scopedSync().write(normalize(to), content);\n  }\n\n  private findUniqueFolderPath(): Observable<Path> {\n    // 11 character alphanumeric string.\n    const randomString = Math.random().toString(36).slice(2);\n    const newFolderName = `test-project-host-${basename(this._templateRoot)}-${randomString}`;\n    const newFolderPath = join(dirname(this._templateRoot), newFolderName);\n\n    return this.exists(newFolderPath).pipe(\n      concatMap(exists => exists ? this.findUniqueFolderPath() : of(newFolderPath)),\n    );\n  }\n}\n"]}

src/architect.d.ts

-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { BaseException, JsonObject, Path, experimental, logging, virtualFs } from '@angular-devkit/core';
-import { Observable } from 'rxjs';
-export declare class ProjectNotFoundException extends BaseException {
-    constructor(projectName: string);
-}
-export declare class TargetNotFoundException extends BaseException {
-    constructor(projectName: string, targetName: string);
-}
-export declare class ConfigurationNotFoundException extends BaseException {
-    constructor(projectName: string, configurationName: string);
-}
-export declare class BuilderCannotBeResolvedException extends BaseException {
-    constructor(builder: string);
-}
-export declare class ArchitectNotYetLoadedException extends BaseException {
-    constructor();
-}
-export declare class BuilderNotFoundException extends BaseException {
-    constructor(builder: string);
-}
-export interface BuilderContext {
-    logger: logging.Logger;
-    host: virtualFs.Host<{}>;
-    workspace: experimental.workspace.Workspace;
-    architect: Architect;
-    targetSpecifier?: TargetSpecifier;
-}
-export interface BuildEvent {
-    success: boolean;
-}
-export interface Builder<OptionsT> {
-    run(builderConfig: BuilderConfiguration<Partial<OptionsT>>): Observable<BuildEvent>;
-}
-export interface BuilderPathsMap {
-    builders: {
-        [k: string]: BuilderPaths;
-    };
-}
-export interface BuilderPaths {
-    class: Path;
-    schema: Path;
-    description: string;
-}
-export interface BuilderDescription {
-    name: string;
-    schema: JsonObject;
-    description: string;
-}
-export interface BuilderConstructor<OptionsT> {
-    new (context: BuilderContext): Builder<OptionsT>;
-}
-export interface BuilderConfiguration<OptionsT = {}> {
-    root: Path;
-    sourceRoot?: Path;
-    projectType: string;
-    builder: string;
-    options: OptionsT;
-}
-export interface TargetSpecifier<OptionsT = {}> {
-    project: string;
-    target: string;
-    configuration?: string;
-    overrides?: Partial<OptionsT>;
-}
-export interface TargetMap {
-    [k: string]: Target;
-}
-export declare type TargetOptions<T = JsonObject> = T;
-export declare type TargetConfiguration<T = JsonObject> = Partial<T>;
-export interface Target<T = JsonObject> {
-    builder: string;
-    options: TargetOptions<T>;
-    configurations?: {
-        [k: string]: TargetConfiguration<T>;
-    };
-}
-export declare class Architect {
-    private _workspace;
-    private readonly _targetsSchemaPath;
-    private readonly _buildersSchemaPath;
-    private _targetsSchema;
-    private _buildersSchema;
-    private _architectSchemasLoaded;
-    private _targetMapMap;
-    private _builderPathsMap;
-    private _builderDescriptionMap;
-    private _builderConstructorMap;
-    constructor(_workspace: experimental.workspace.Workspace);
-    loadArchitect(): Observable<this>;
-    listProjectTargets(projectName: string): string[];
-    private _getProjectTargetMap;
-    private _getProjectTarget;
-    getBuilderConfiguration<OptionsT>(targetSpec: TargetSpecifier): BuilderConfiguration<OptionsT>;
-    run<OptionsT>(builderConfig: BuilderConfiguration<OptionsT>, partialContext?: Partial<BuilderContext>): Observable<BuildEvent>;
-    getBuilderDescription<OptionsT>(builderConfig: BuilderConfiguration<OptionsT>): Observable<BuilderDescription>;
-    validateBuilderOptions<OptionsT>(builderConfig: BuilderConfiguration<OptionsT>, builderDescription: BuilderDescription): Observable<BuilderConfiguration<OptionsT>>;
-    getBuilder<OptionsT>(builderDescription: BuilderDescription, context: BuilderContext): Builder<OptionsT>;
-    private _loadJsonFile;
-}

src/architect.js

-"use strict";
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@angular-devkit/core");
-const node_1 = require("@angular-devkit/core/node");
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-class ProjectNotFoundException extends core_1.BaseException {
-    constructor(projectName) {
-        super(`Project '${projectName}' could not be found in Workspace.`);
-    }
-}
-exports.ProjectNotFoundException = ProjectNotFoundException;
-class TargetNotFoundException extends core_1.BaseException {
-    constructor(projectName, targetName) {
-        super(`Target '${targetName}' could not be found in project '${projectName}'.`);
-    }
-}
-exports.TargetNotFoundException = TargetNotFoundException;
-class ConfigurationNotFoundException extends core_1.BaseException {
-    constructor(projectName, configurationName) {
-        super(`Configuration '${configurationName}' could not be found in project '${projectName}'.`);
-    }
-}
-exports.ConfigurationNotFoundException = ConfigurationNotFoundException;
-// TODO: break this exception apart into more granular ones.
-class BuilderCannotBeResolvedException extends core_1.BaseException {
-    constructor(builder) {
-        super(`Builder '${builder}' cannot be resolved.`);
-    }
-}
-exports.BuilderCannotBeResolvedException = BuilderCannotBeResolvedException;
-class ArchitectNotYetLoadedException extends core_1.BaseException {
-    constructor() { super(`Architect needs to be loaded before Architect is used.`); }
-}
-exports.ArchitectNotYetLoadedException = ArchitectNotYetLoadedException;
-class BuilderNotFoundException extends core_1.BaseException {
-    constructor(builder) {
-        super(`Builder ${builder} could not be found.`);
-    }
-}
-exports.BuilderNotFoundException = BuilderNotFoundException;
-class Architect {
-    constructor(_workspace) {
-        this._workspace = _workspace;
-        this._targetsSchemaPath = core_1.join(core_1.normalize(__dirname), 'targets-schema.json');
-        this._buildersSchemaPath = core_1.join(core_1.normalize(__dirname), 'builders-schema.json');
-        this._architectSchemasLoaded = false;
-        this._targetMapMap = new Map();
-        this._builderPathsMap = new Map();
-        this._builderDescriptionMap = new Map();
-        this._builderConstructorMap = new Map();
-    }
-    loadArchitect() {
-        if (this._architectSchemasLoaded) {
-            return rxjs_1.of(this);
-        }
-        else {
-            return rxjs_1.forkJoin(this._loadJsonFile(this._targetsSchemaPath), this._loadJsonFile(this._buildersSchemaPath)).pipe(operators_1.concatMap(([targetsSchema, buildersSchema]) => {
-                this._targetsSchema = targetsSchema;
-                this._buildersSchema = buildersSchema;
-                this._architectSchemasLoaded = true;
-                // Validate and cache all project target maps.
-                return rxjs_1.forkJoin(...this._workspace.listProjectNames().map(projectName => {
-                    const unvalidatedTargetMap = this._workspace.getProjectTargets(projectName);
-                    return this._workspace.validateAgainstSchema(unvalidatedTargetMap, this._targetsSchema).pipe(operators_1.tap(targetMap => this._targetMapMap.set(projectName, targetMap)));
-                }));
-            }), operators_1.map(() => this));
-        }
-    }
-    listProjectTargets(projectName) {
-        return Object.keys(this._getProjectTargetMap(projectName));
-    }
-    _getProjectTargetMap(projectName) {
-        if (!this._targetMapMap.has(projectName)) {
-            throw new ProjectNotFoundException(projectName);
-        }
-        return this._targetMapMap.get(projectName);
-    }
-    _getProjectTarget(projectName, targetName) {
-        const targetMap = this._getProjectTargetMap(projectName);
-        const target = targetMap[targetName];
-        if (!target) {
-            throw new TargetNotFoundException(projectName, targetName);
-        }
-        return target;
-    }
-    getBuilderConfiguration(targetSpec) {
-        const { project: projectName, target: targetName, configuration: configurationName, overrides, } = targetSpec;
-        const project = this._workspace.getProject(projectName);
-        const target = this._getProjectTarget(projectName, targetName);
-        const options = target.options;
-        let configuration = {};
-        if (configurationName) {
-            if (!target.configurations) {
-                throw new ConfigurationNotFoundException(projectName, configurationName);
-            }
-            configuration = target.configurations[configurationName];
-            if (!configuration) {
-                throw new ConfigurationNotFoundException(projectName, configurationName);
-            }
-        }
-        const builderConfiguration = {
-            root: project.root,
-            sourceRoot: project.sourceRoot,
-            projectType: project.projectType,
-            builder: target.builder,
-            options: Object.assign({}, options, configuration, overrides),
-        };
-        return builderConfiguration;
-    }
-    run(builderConfig, partialContext = {}) {
-        const context = Object.assign({ logger: new core_1.logging.NullLogger(), architect: this, host: this._workspace.host, workspace: this._workspace }, partialContext);
-        let builderDescription;
-        return this.getBuilderDescription(builderConfig).pipe(operators_1.tap(description => builderDescription = description), operators_1.concatMap(() => this.validateBuilderOptions(builderConfig, builderDescription)), operators_1.tap(validatedBuilderConfig => builderConfig = validatedBuilderConfig), operators_1.map(() => this.getBuilder(builderDescription, context)), operators_1.concatMap(builder => builder.run(builderConfig)));
-    }
-    getBuilderDescription(builderConfig) {
-        // Check cache for this builder description.
-        if (this._builderDescriptionMap.has(builderConfig.builder)) {
-            return rxjs_1.of(this._builderDescriptionMap.get(builderConfig.builder));
-        }
-        return new rxjs_1.Observable((obs) => {
-            // TODO: this probably needs to be more like NodeModulesEngineHost.
-            const basedir = core_1.getSystemPath(this._workspace.root);
-            const [pkg, builderName] = builderConfig.builder.split(':');
-            const pkgJsonPath = node_1.resolve(pkg, { basedir, resolvePackageJson: true, checkLocal: true });
-            let buildersJsonPath;
-            let builderPaths;
-            // Read the `builders` entry of package.json.
-            return this._loadJsonFile(core_1.normalize(pkgJsonPath)).pipe(operators_1.concatMap((pkgJson) => {
-                const pkgJsonBuildersentry = pkgJson['builders'];
-                if (!pkgJsonBuildersentry) {
-                    return rxjs_1.throwError(new BuilderCannotBeResolvedException(builderConfig.builder));
-                }
-                buildersJsonPath = core_1.join(core_1.dirname(core_1.normalize(pkgJsonPath)), pkgJsonBuildersentry);
-                return this._loadJsonFile(buildersJsonPath);
-            }), 
-            // Validate builders json.
-            operators_1.concatMap((builderPathsMap) => this._workspace.validateAgainstSchema(builderPathsMap, this._buildersSchema)), operators_1.concatMap((builderPathsMap) => {
-                builderPaths = builderPathsMap.builders[builderName];
-                if (!builderPaths) {
-                    return rxjs_1.throwError(new BuilderCannotBeResolvedException(builderConfig.builder));
-                }
-                // Resolve paths in the builder paths.
-                const builderJsonDir = core_1.dirname(buildersJsonPath);
-                builderPaths.schema = core_1.join(builderJsonDir, builderPaths.schema);
-                builderPaths.class = core_1.join(builderJsonDir, builderPaths.class);
-                // Save the builder paths so that we can lazily load the builder.
-                this._builderPathsMap.set(builderConfig.builder, builderPaths);
-                // Load the schema.
-                return this._loadJsonFile(builderPaths.schema);
-            }), operators_1.map(builderSchema => {
-                const builderDescription = {
-                    name: builderConfig.builder,
-                    schema: builderSchema,
-                    description: builderPaths.description,
-                };
-                // Save to cache before returning.
-                this._builderDescriptionMap.set(builderDescription.name, builderDescription);
-                return builderDescription;
-            })).subscribe(obs);
-        });
-    }
-    validateBuilderOptions(builderConfig, builderDescription) {
-        return this._workspace.validateAgainstSchema(builderConfig.options, builderDescription.schema).pipe(operators_1.map(validatedOptions => {
-            builderConfig.options = validatedOptions;
-            return builderConfig;
-        }));
-    }
-    getBuilder(builderDescription, context) {
-        const name = builderDescription.name;
-        let builderConstructor;
-        // Check cache for this builder.
-        if (this._builderConstructorMap.has(name)) {
-            builderConstructor = this._builderConstructorMap.get(name);
-        }
-        else {
-            if (!this._builderPathsMap.has(name)) {
-                throw new BuilderNotFoundException(name);
-            }
-            const builderPaths = this._builderPathsMap.get(name);
-            // TODO: support more than the default export, maybe via builder#import-name.
-            const builderModule = require(core_1.getSystemPath(builderPaths.class));
-            builderConstructor = builderModule['default'];
-            // Save builder to cache before returning.
-            this._builderConstructorMap.set(builderDescription.name, builderConstructor);
-        }
-        const builder = new builderConstructor(context);
-        return builder;
-    }
-    _loadJsonFile(path) {
-        return this._workspace.host.read(core_1.normalize(path)).pipe(operators_1.map(buffer => core_1.virtualFs.fileBufferToString(buffer)), operators_1.map(str => core_1.parseJson(str, core_1.JsonParseMode.Loose)));
-    }
-}
-exports.Architect = Architect;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"architect.js","sourceRoot":"./","sources":["packages/angular_devkit/architect/src/architect.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  BaseException,\n  JsonObject,\n  JsonParseMode,\n  Path,\n  dirname,\n  experimental,\n  getSystemPath,\n  join,\n  logging,\n  normalize,\n  parseJson,\n  virtualFs,\n} from '@angular-devkit/core';\nimport { resolve as nodeResolve } from '@angular-devkit/core/node';\nimport { Observable, forkJoin, of, throwError } from 'rxjs';\nimport { concatMap, map, tap } from 'rxjs/operators';\n\nexport class ProjectNotFoundException extends BaseException {\n  constructor(projectName: string) {\n    super(`Project '${projectName}' could not be found in Workspace.`);\n  }\n}\n\nexport class TargetNotFoundException extends BaseException {\n  constructor(projectName: string, targetName: string) {\n    super(`Target '${targetName}' could not be found in project '${projectName}'.`);\n  }\n}\n\nexport class ConfigurationNotFoundException extends BaseException {\n  constructor(projectName: string, configurationName: string) {\n    super(`Configuration '${configurationName}' could not be found in project '${projectName}'.`);\n  }\n}\n\n// TODO: break this exception apart into more granular ones.\nexport class BuilderCannotBeResolvedException extends BaseException {\n  constructor(builder: string) {\n    super(`Builder '${builder}' cannot be resolved.`);\n  }\n}\n\nexport class ArchitectNotYetLoadedException extends BaseException {\n  constructor() { super(`Architect needs to be loaded before Architect is used.`); }\n}\n\nexport class BuilderNotFoundException extends BaseException {\n  constructor(builder: string) {\n    super(`Builder ${builder} could not be found.`);\n  }\n}\n\nexport interface BuilderContext {\n  logger: logging.Logger;\n  host: virtualFs.Host<{}>;\n  workspace: experimental.workspace.Workspace;\n  architect: Architect;\n  targetSpecifier?: TargetSpecifier;\n}\n\n// TODO: use Build Event Protocol\n// https://docs.bazel.build/versions/master/build-event-protocol.html\n// https://github.com/googleapis/googleapis/tree/master/google/devtools/build/v1\nexport interface BuildEvent {\n  success: boolean;\n}\n\nexport interface Builder<OptionsT> {\n  run(builderConfig: BuilderConfiguration<Partial<OptionsT>>): Observable<BuildEvent>;\n}\n\nexport interface BuilderPathsMap {\n  builders: { [k: string]: BuilderPaths };\n}\n\nexport interface BuilderPaths {\n  class: Path;\n  schema: Path;\n  description: string;\n}\n\nexport interface BuilderDescription {\n  name: string;\n  schema: JsonObject;\n  description: string;\n}\n\nexport interface BuilderConstructor<OptionsT> {\n  new(context: BuilderContext): Builder<OptionsT>;\n}\n\nexport interface BuilderConfiguration<OptionsT = {}> {\n  root: Path;\n  sourceRoot?: Path;\n  projectType: string;\n  builder: string;\n  options: OptionsT;\n}\n\nexport interface TargetSpecifier<OptionsT = {}> {\n  project: string;\n  target: string;\n  configuration?: string;\n  overrides?: Partial<OptionsT>;\n}\n\nexport interface TargetMap {\n  [k: string]: Target;\n}\n\nexport declare type TargetOptions<T = JsonObject> = T;\nexport declare type TargetConfiguration<T = JsonObject> = Partial<T>;\n\nexport interface Target<T = JsonObject> {\n  builder: string;\n  options: TargetOptions<T>;\n  configurations?: { [k: string]: TargetConfiguration<T> };\n}\n\nexport class Architect {\n  private readonly _targetsSchemaPath = join(normalize(__dirname), 'targets-schema.json');\n  private readonly _buildersSchemaPath = join(normalize(__dirname), 'builders-schema.json');\n  private _targetsSchema: JsonObject;\n  private _buildersSchema: JsonObject;\n  private _architectSchemasLoaded = false;\n  private _targetMapMap = new Map<string, TargetMap>();\n  private _builderPathsMap = new Map<string, BuilderPaths>();\n  private _builderDescriptionMap = new Map<string, BuilderDescription>();\n  private _builderConstructorMap = new Map<string, BuilderConstructor<{}>>();\n\n  constructor(private _workspace: experimental.workspace.Workspace) { }\n\n  loadArchitect() {\n    if (this._architectSchemasLoaded) {\n      return of(this);\n    } else {\n      return forkJoin(\n        this._loadJsonFile(this._targetsSchemaPath),\n        this._loadJsonFile(this._buildersSchemaPath),\n      ).pipe(\n        concatMap(([targetsSchema, buildersSchema]) => {\n          this._targetsSchema = targetsSchema;\n          this._buildersSchema = buildersSchema;\n          this._architectSchemasLoaded = true;\n\n          // Validate and cache all project target maps.\n          return forkJoin(\n            ...this._workspace.listProjectNames().map(projectName => {\n              const unvalidatedTargetMap = this._workspace.getProjectTargets(projectName);\n\n              return this._workspace.validateAgainstSchema<TargetMap>(\n                unvalidatedTargetMap, this._targetsSchema).pipe(\n                  tap(targetMap => this._targetMapMap.set(projectName, targetMap)),\n              );\n            }),\n          );\n        }),\n        map(() => this),\n      );\n    }\n  }\n\n  listProjectTargets(projectName: string): string[] {\n    return Object.keys(this._getProjectTargetMap(projectName));\n  }\n\n  private _getProjectTargetMap(projectName: string): TargetMap {\n    if (!this._targetMapMap.has(projectName)) {\n      throw new ProjectNotFoundException(projectName);\n    }\n\n    return this._targetMapMap.get(projectName) as TargetMap;\n  }\n\n  private _getProjectTarget<T = {}>(projectName: string, targetName: string): Target<T> {\n    const targetMap = this._getProjectTargetMap(projectName);\n\n    const target = targetMap[targetName] as {} as Target<T>;\n\n    if (!target) {\n      throw new TargetNotFoundException(projectName, targetName);\n    }\n\n    return target;\n  }\n\n  getBuilderConfiguration<OptionsT>(targetSpec: TargetSpecifier): BuilderConfiguration<OptionsT> {\n    const {\n      project: projectName,\n      target: targetName,\n      configuration: configurationName,\n      overrides,\n    } = targetSpec;\n\n    const project = this._workspace.getProject(projectName);\n    const target = this._getProjectTarget(projectName, targetName);\n    const options = target.options;\n    let configuration: TargetConfiguration = {};\n\n    if (configurationName) {\n      if (!target.configurations) {\n        throw new ConfigurationNotFoundException(projectName, configurationName);\n      }\n\n      configuration = target.configurations[configurationName];\n\n      if (!configuration) {\n        throw new ConfigurationNotFoundException(projectName, configurationName);\n      }\n    }\n\n    const builderConfiguration: BuilderConfiguration<OptionsT> = {\n      root: project.root as Path,\n      sourceRoot: project.sourceRoot as Path | undefined,\n      projectType: project.projectType,\n      builder: target.builder,\n      options: {\n        ...options,\n        ...configuration,\n        ...overrides as {},\n      } as OptionsT,\n    };\n\n    return builderConfiguration;\n  }\n\n  run<OptionsT>(\n    builderConfig: BuilderConfiguration<OptionsT>,\n    partialContext: Partial<BuilderContext> = {},\n  ): Observable<BuildEvent> {\n    const context: BuilderContext = {\n      logger: new logging.NullLogger(),\n      architect: this,\n      host: this._workspace.host,\n      workspace: this._workspace,\n      ...partialContext,\n    };\n\n    let builderDescription: BuilderDescription;\n\n    return this.getBuilderDescription(builderConfig).pipe(\n      tap(description => builderDescription = description),\n      concatMap(() => this.validateBuilderOptions(builderConfig, builderDescription)),\n      tap(validatedBuilderConfig => builderConfig = validatedBuilderConfig),\n      map(() => this.getBuilder(builderDescription, context)),\n      concatMap(builder => builder.run(builderConfig)),\n    );\n  }\n\n  getBuilderDescription<OptionsT>(\n    builderConfig: BuilderConfiguration<OptionsT>,\n  ): Observable<BuilderDescription> {\n    // Check cache for this builder description.\n    if (this._builderDescriptionMap.has(builderConfig.builder)) {\n      return of(this._builderDescriptionMap.get(builderConfig.builder) as BuilderDescription);\n    }\n\n    return new Observable((obs) => {\n      // TODO: this probably needs to be more like NodeModulesEngineHost.\n      const basedir = getSystemPath(this._workspace.root);\n      const [pkg, builderName] = builderConfig.builder.split(':');\n      const pkgJsonPath = nodeResolve(pkg, { basedir, resolvePackageJson: true, checkLocal: true });\n      let buildersJsonPath: Path;\n      let builderPaths: BuilderPaths;\n\n      // Read the `builders` entry of package.json.\n      return this._loadJsonFile(normalize(pkgJsonPath)).pipe(\n        concatMap((pkgJson: JsonObject) => {\n          const pkgJsonBuildersentry = pkgJson['builders'] as string;\n          if (!pkgJsonBuildersentry) {\n            return throwError(new BuilderCannotBeResolvedException(builderConfig.builder));\n          }\n\n          buildersJsonPath = join(dirname(normalize(pkgJsonPath)), pkgJsonBuildersentry);\n\n          return this._loadJsonFile(buildersJsonPath);\n        }),\n        // Validate builders json.\n        concatMap((builderPathsMap) => this._workspace.validateAgainstSchema<BuilderPathsMap>(\n          builderPathsMap, this._buildersSchema)),\n        concatMap((builderPathsMap) => {\n          builderPaths = builderPathsMap.builders[builderName];\n\n          if (!builderPaths) {\n            return throwError(new BuilderCannotBeResolvedException(builderConfig.builder));\n          }\n\n          // Resolve paths in the builder paths.\n          const builderJsonDir = dirname(buildersJsonPath);\n          builderPaths.schema = join(builderJsonDir, builderPaths.schema);\n          builderPaths.class = join(builderJsonDir, builderPaths.class);\n\n          // Save the builder paths so that we can lazily load the builder.\n          this._builderPathsMap.set(builderConfig.builder, builderPaths);\n\n          // Load the schema.\n          return this._loadJsonFile(builderPaths.schema);\n        }),\n        map(builderSchema => {\n          const builderDescription = {\n            name: builderConfig.builder,\n            schema: builderSchema,\n            description: builderPaths.description,\n          };\n\n          // Save to cache before returning.\n          this._builderDescriptionMap.set(builderDescription.name, builderDescription);\n\n          return builderDescription;\n        }),\n      ).subscribe(obs);\n    });\n  }\n\n  validateBuilderOptions<OptionsT>(\n    builderConfig: BuilderConfiguration<OptionsT>, builderDescription: BuilderDescription,\n  ): Observable<BuilderConfiguration<OptionsT>> {\n    return this._workspace.validateAgainstSchema<OptionsT>(\n      builderConfig.options, builderDescription.schema,\n    ).pipe(\n      map(validatedOptions => {\n        builderConfig.options = validatedOptions;\n\n        return builderConfig;\n      }),\n    );\n  }\n\n  getBuilder<OptionsT>(\n    builderDescription: BuilderDescription, context: BuilderContext,\n  ): Builder<OptionsT> {\n    const name = builderDescription.name;\n    let builderConstructor: BuilderConstructor<OptionsT>;\n\n    // Check cache for this builder.\n    if (this._builderConstructorMap.has(name)) {\n      builderConstructor = this._builderConstructorMap.get(name) as BuilderConstructor<OptionsT>;\n    } else {\n      if (!this._builderPathsMap.has(name)) {\n        throw new BuilderNotFoundException(name);\n      }\n\n      const builderPaths = this._builderPathsMap.get(name) as BuilderPaths;\n\n      // TODO: support more than the default export, maybe via builder#import-name.\n      const builderModule = require(getSystemPath(builderPaths.class));\n      builderConstructor = builderModule['default'] as BuilderConstructor<OptionsT>;\n\n      // Save builder to cache before returning.\n      this._builderConstructorMap.set(builderDescription.name, builderConstructor);\n    }\n\n    const builder = new builderConstructor(context);\n\n    return builder;\n  }\n\n  private _loadJsonFile(path: Path): Observable<JsonObject> {\n    return this._workspace.host.read(normalize(path)).pipe(\n      map(buffer => virtualFs.fileBufferToString(buffer)),\n      map(str => parseJson(str, JsonParseMode.Loose) as {} as JsonObject),\n    );\n  }\n}\n"]}

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Network access

Supply chain risk

This module accesses the network.

Found 2 instances in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Fixed alerts

Network access

Supply chain risk

This module accesses the network.

Found 2 instances in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

95947

2.27%

Lines of code

986

12.94%

Worsened metrics

Number of medium supply chain risk alerts

3

50%

Dependency changes

• + Added

  @angular-devkit/core@7.3.0-beta.0
  (transitive)

• + Added

  ajv@6.7.0
  (transitive)

• - Removed

  @angular-devkit/core@7.2.1
  (transitive)

• - Removed

  ajv@6.6.2
  (transitive)

• Updated

  @angular-devkit/core@7.3.0-beta.0