@angular-devkit/schematics/src/engine/engine.js

"use strict";
/**
 * @license
 * 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
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.SchematicEngine = exports.TaskScheduler = exports.CollectionImpl = exports.UnknownTaskDependencyException = exports.UnregisteredTaskException = exports.SchematicEngineConflictingException = exports.PrivateSchematicException = exports.UnknownSchematicException = exports.CircularCollectionException = exports.UnknownCollectionException = exports.UnknownUrlSourceProtocol = void 0;
const core_1 = require("@angular-devkit/core");
const rxjs_1 = require("rxjs");
const operators_1 = require("rxjs/operators");
const interface_1 = require("../tree/interface");
const null_1 = require("../tree/null");
const static_1 = require("../tree/static");
const schematic_1 = require("./schematic");
class UnknownUrlSourceProtocol extends core_1.BaseException {
    constructor(url) {
        super(`Unknown Protocol on url "${url}".`);
    }
}
exports.UnknownUrlSourceProtocol = UnknownUrlSourceProtocol;
class UnknownCollectionException extends core_1.BaseException {
    constructor(name) {
        super(`Unknown collection "${name}".`);
    }
}
exports.UnknownCollectionException = UnknownCollectionException;
class CircularCollectionException extends core_1.BaseException {
    constructor(name) {
        super(`Circular collection reference "${name}".`);
    }
}
exports.CircularCollectionException = CircularCollectionException;
class UnknownSchematicException extends core_1.BaseException {
    constructor(name, collection) {
        super(`Schematic "${name}" not found in collection "${collection.name}".`);
    }
}
exports.UnknownSchematicException = UnknownSchematicException;
class PrivateSchematicException extends core_1.BaseException {
    constructor(name, collection) {
        super(`Schematic "${name}" not found in collection "${collection.name}".`);
    }
}
exports.PrivateSchematicException = PrivateSchematicException;
class SchematicEngineConflictingException extends core_1.BaseException {
    constructor() {
        super(`A schematic was called from a different engine as its parent.`);
    }
}
exports.SchematicEngineConflictingException = SchematicEngineConflictingException;
class UnregisteredTaskException extends core_1.BaseException {
    constructor(name, schematic) {
        const addendum = schematic ? ` in schematic "${schematic.name}"` : '';
        super(`Unregistered task "${name}"${addendum}.`);
    }
}
exports.UnregisteredTaskException = UnregisteredTaskException;
class UnknownTaskDependencyException extends core_1.BaseException {
    constructor(id) {
        super(`Unknown task dependency [ID: ${id.id}].`);
    }
}
exports.UnknownTaskDependencyException = UnknownTaskDependencyException;
class CollectionImpl {
    constructor(_description, _engine, baseDescriptions) {
        this._description = _description;
        this._engine = _engine;
        this.baseDescriptions = baseDescriptions;
    }
    get description() {
        return this._description;
    }
    get name() {
        return this.description.name || '<unknown>';
    }
    createSchematic(name, allowPrivate = false) {
        return this._engine.createSchematic(name, this, allowPrivate);
    }
    listSchematicNames(includeHidden) {
        return this._engine.listSchematicNames(this, includeHidden);
    }
}
exports.CollectionImpl = CollectionImpl;
class TaskScheduler {
    constructor(_context) {
        this._context = _context;
        this._queue = new core_1.PriorityQueue((x, y) => x.priority - y.priority);
        this._taskIds = new Map();
    }
    _calculatePriority(dependencies) {
        if (dependencies.size === 0) {
            return 0;
        }
        const prio = [...dependencies].reduce((prio, task) => prio + task.priority, 1);
        return prio;
    }
    _mapDependencies(dependencies) {
        if (!dependencies) {
            return new Set();
        }
        const tasks = dependencies.map((dep) => {
            const task = this._taskIds.get(dep);
            if (!task) {
                throw new UnknownTaskDependencyException(dep);
            }
            return task;
        });
        return new Set(tasks);
    }
    schedule(taskConfiguration) {
        const dependencies = this._mapDependencies(taskConfiguration.dependencies);
        const priority = this._calculatePriority(dependencies);
        const task = {
            id: TaskScheduler._taskIdCounter++,
            priority,
            configuration: taskConfiguration,
            context: this._context,
        };
        this._queue.push(task);
        const id = { id: task.id };
        this._taskIds.set(id, task);
        return id;
    }
    finalize() {
        const tasks = this._queue.toArray();
        this._queue.clear();
        this._taskIds.clear();
        return tasks;
    }
}
exports.TaskScheduler = TaskScheduler;
TaskScheduler._taskIdCounter = 1;
class SchematicEngine {
    constructor(_host, _workflow) {
        this._host = _host;
        this._workflow = _workflow;
        this._collectionCache = new Map();
        this._schematicCache = new WeakMap();
        this._taskSchedulers = new Array();
    }
    get workflow() {
        return this._workflow || null;
    }
    get defaultMergeStrategy() {
        return this._host.defaultMergeStrategy || interface_1.MergeStrategy.Default;
    }
    createCollection(name, requester) {
        let collection = this._collectionCache.get(name);
        if (collection) {
            return collection;
        }
        const [description, bases] = this._createCollectionDescription(name, requester === null || requester === void 0 ? void 0 : requester.description);
        collection = new CollectionImpl(description, this, bases);
        this._collectionCache.set(name, collection);
        this._schematicCache.set(collection, new Map());
        return collection;
    }
    _createCollectionDescription(name, requester, parentNames) {
        const description = this._host.createCollectionDescription(name, requester);
        if (!description) {
            throw new UnknownCollectionException(name);
        }
        if (parentNames && parentNames.has(description.name)) {
            throw new CircularCollectionException(name);
        }
        const bases = new Array();
        if (description.extends) {
            parentNames = (parentNames || new Set()).add(description.name);
            for (const baseName of description.extends) {
                const [base, baseBases] = this._createCollectionDescription(baseName, description, new Set(parentNames));
                bases.unshift(base, ...baseBases);
            }
        }
        return [description, bases];
    }
    createContext(schematic, parent, executionOptions) {
        // Check for inconsistencies.
        if (parent && parent.engine && parent.engine !== this) {
            throw new SchematicEngineConflictingException();
        }
        let interactive = true;
        if (executionOptions && executionOptions.interactive != undefined) {
            interactive = executionOptions.interactive;
        }
        else if (parent && parent.interactive != undefined) {
            interactive = parent.interactive;
        }
        let context = {
            debug: (parent && parent.debug) || false,
            engine: this,
            logger: (parent && parent.logger && parent.logger.createChild(schematic.description.name)) ||
                new core_1.logging.NullLogger(),
            schematic,
            strategy: parent && parent.strategy !== undefined ? parent.strategy : this.defaultMergeStrategy,
            interactive,
            addTask,
        };
        const maybeNewContext = this._host.transformContext(context);
        if (maybeNewContext) {
            context = maybeNewContext;
        }
        const taskScheduler = new TaskScheduler(context);
        const host = this._host;
        this._taskSchedulers.push(taskScheduler);
        function addTask(task, dependencies) {
            const config = task.toConfiguration();
            if (!host.hasTaskExecutor(config.name)) {
                throw new UnregisteredTaskException(config.name, schematic.description);
            }
            config.dependencies = config.dependencies || [];
            if (dependencies) {
                config.dependencies.unshift(...dependencies);
            }
            return taskScheduler.schedule(config);
        }
        return context;
    }
    createSchematic(name, collection, allowPrivate = false) {
        const schematicMap = this._schematicCache.get(collection);
        let schematic = schematicMap === null || schematicMap === void 0 ? void 0 : schematicMap.get(name);
        if (schematic) {
            return schematic;
        }
        let collectionDescription = collection.description;
        let description = this._host.createSchematicDescription(name, collection.description);
        if (!description) {
            if (collection.baseDescriptions) {
                for (const base of collection.baseDescriptions) {
                    description = this._host.createSchematicDescription(name, base);
                    if (description) {
                        collectionDescription = base;
                        break;
                    }
                }
            }
            if (!description) {
                // Report the error for the top level schematic collection
                throw new UnknownSchematicException(name, collection.description);
            }
        }
        if (description.private && !allowPrivate) {
            throw new PrivateSchematicException(name, collection.description);
        }
        const factory = this._host.getSchematicRuleFactory(description, collectionDescription);
        schematic = new schematic_1.SchematicImpl(description, factory, collection, this);
        schematicMap === null || schematicMap === void 0 ? void 0 : schematicMap.set(name, schematic);
        return schematic;
    }
    listSchematicNames(collection, includeHidden) {
        const names = this._host.listSchematicNames(collection.description, includeHidden);
        if (collection.baseDescriptions) {
            for (const base of collection.baseDescriptions) {
                names.push(...this._host.listSchematicNames(base, includeHidden));
            }
        }
        // remove duplicates
        return [...new Set(names)].sort();
    }
    transformOptions(schematic, options, context) {
        return this._host.transformOptions(schematic.description, options, context);
    }
    createSourceFromUrl(url, context) {
        switch (url.protocol) {
            case 'null:':
                return () => new null_1.NullTree();
            case 'empty:':
                return () => (0, static_1.empty)();
            default:
                const hostSource = this._host.createSourceFromUrl(url, context);
                if (!hostSource) {
                    throw new UnknownUrlSourceProtocol(url.toString());
                }
                return hostSource;
        }
    }
    executePostTasks() {
        const executors = new Map();
        const taskObservable = (0, rxjs_1.from)(this._taskSchedulers).pipe((0, operators_1.concatMap)((scheduler) => scheduler.finalize()), (0, operators_1.concatMap)((task) => {
            const { name, options } = task.configuration;
            const executor = executors.get(name);
            if (executor) {
                return executor(options, task.context);
            }
            return this._host.createTaskExecutor(name).pipe((0, operators_1.concatMap)((executor) => {
                executors.set(name, executor);
                return executor(options, task.context);
            }));
        }));
        return taskObservable;
    }
}
exports.SchematicEngine = SchematicEngine;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../../../../../../../packages/angular_devkit/schematics/src/engine/engine.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 { BaseException, PriorityQueue, logging } from '@angular-devkit/core';\nimport { Observable, from as observableFrom } from 'rxjs';\nimport { concatMap } from 'rxjs/operators';\nimport { Url } from 'url';\nimport { MergeStrategy } from '../tree/interface';\nimport { NullTree } from '../tree/null';\nimport { empty } from '../tree/static';\nimport { Workflow } from '../workflow/interface';\nimport {\n  Collection,\n  CollectionDescription,\n  Engine,\n  EngineHost,\n  ExecutionOptions,\n  Schematic,\n  SchematicContext,\n  SchematicDescription,\n  Source,\n  TaskConfiguration,\n  TaskConfigurationGenerator,\n  TaskExecutor,\n  TaskId,\n  TaskInfo,\n  TypedSchematicContext,\n} from './interface';\nimport { SchematicImpl } from './schematic';\n\nexport class UnknownUrlSourceProtocol extends BaseException {\n  constructor(url: string) {\n    super(`Unknown Protocol on url \"${url}\".`);\n  }\n}\n\nexport class UnknownCollectionException extends BaseException {\n  constructor(name: string) {\n    super(`Unknown collection \"${name}\".`);\n  }\n}\n\nexport class CircularCollectionException extends BaseException {\n  constructor(name: string) {\n    super(`Circular collection reference \"${name}\".`);\n  }\n}\n\nexport class UnknownSchematicException extends BaseException {\n  constructor(name: string, collection: CollectionDescription<{}>) {\n    super(`Schematic \"${name}\" not found in collection \"${collection.name}\".`);\n  }\n}\n\nexport class PrivateSchematicException extends BaseException {\n  constructor(name: string, collection: CollectionDescription<{}>) {\n    super(`Schematic \"${name}\" not found in collection \"${collection.name}\".`);\n  }\n}\n\nexport class SchematicEngineConflictingException extends BaseException {\n  constructor() {\n    super(`A schematic was called from a different engine as its parent.`);\n  }\n}\n\nexport class UnregisteredTaskException extends BaseException {\n  constructor(name: string, schematic?: SchematicDescription<{}, {}>) {\n    const addendum = schematic ? ` in schematic \"${schematic.name}\"` : '';\n    super(`Unregistered task \"${name}\"${addendum}.`);\n  }\n}\n\nexport class UnknownTaskDependencyException extends BaseException {\n  constructor(id: TaskId) {\n    super(`Unknown task dependency [ID: ${id.id}].`);\n  }\n}\n\nexport class CollectionImpl<CollectionT extends object, SchematicT extends object>\n  implements Collection<CollectionT, SchematicT>\n{\n  constructor(\n    private _description: CollectionDescription<CollectionT>,\n    private _engine: SchematicEngine<CollectionT, SchematicT>,\n    public readonly baseDescriptions?: Array<CollectionDescription<CollectionT>>,\n  ) {}\n\n  get description() {\n    return this._description;\n  }\n  get name() {\n    return this.description.name || '<unknown>';\n  }\n\n  createSchematic(name: string, allowPrivate = false): Schematic<CollectionT, SchematicT> {\n    return this._engine.createSchematic(name, this, allowPrivate);\n  }\n\n  listSchematicNames(includeHidden?: boolean): string[] {\n    return this._engine.listSchematicNames(this, includeHidden);\n  }\n}\n\nexport class TaskScheduler {\n  private _queue = new PriorityQueue<TaskInfo>((x, y) => x.priority - y.priority);\n  private _taskIds = new Map<TaskId, TaskInfo>();\n  private static _taskIdCounter = 1;\n\n  constructor(private _context: SchematicContext) {}\n\n  private _calculatePriority(dependencies: Set<TaskInfo>): number {\n    if (dependencies.size === 0) {\n      return 0;\n    }\n\n    const prio = [...dependencies].reduce((prio, task) => prio + task.priority, 1);\n\n    return prio;\n  }\n\n  private _mapDependencies(dependencies?: Array<TaskId>): Set<TaskInfo> {\n    if (!dependencies) {\n      return new Set();\n    }\n\n    const tasks = dependencies.map((dep) => {\n      const task = this._taskIds.get(dep);\n      if (!task) {\n        throw new UnknownTaskDependencyException(dep);\n      }\n\n      return task;\n    });\n\n    return new Set(tasks);\n  }\n\n  schedule<T extends object>(taskConfiguration: TaskConfiguration<T>): TaskId {\n    const dependencies = this._mapDependencies(taskConfiguration.dependencies);\n    const priority = this._calculatePriority(dependencies);\n\n    const task = {\n      id: TaskScheduler._taskIdCounter++,\n      priority,\n      configuration: taskConfiguration,\n      context: this._context,\n    };\n\n    this._queue.push(task);\n\n    const id = { id: task.id };\n    this._taskIds.set(id, task);\n\n    return id;\n  }\n\n  finalize(): ReadonlyArray<TaskInfo> {\n    const tasks = this._queue.toArray();\n    this._queue.clear();\n    this._taskIds.clear();\n\n    return tasks;\n  }\n}\n\nexport class SchematicEngine<CollectionT extends object, SchematicT extends object>\n  implements Engine<CollectionT, SchematicT>\n{\n  private _collectionCache = new Map<string, CollectionImpl<CollectionT, SchematicT>>();\n  private _schematicCache = new WeakMap<\n    Collection<CollectionT, SchematicT>,\n    Map<string, SchematicImpl<CollectionT, SchematicT>>\n  >();\n  private _taskSchedulers = new Array<TaskScheduler>();\n\n  constructor(private _host: EngineHost<CollectionT, SchematicT>, protected _workflow?: Workflow) {}\n\n  get workflow() {\n    return this._workflow || null;\n  }\n  get defaultMergeStrategy() {\n    return this._host.defaultMergeStrategy || MergeStrategy.Default;\n  }\n\n  createCollection(\n    name: string,\n    requester?: Collection<CollectionT, SchematicT>,\n  ): Collection<CollectionT, SchematicT> {\n    let collection = this._collectionCache.get(name);\n    if (collection) {\n      return collection;\n    }\n\n    const [description, bases] = this._createCollectionDescription(name, requester?.description);\n\n    collection = new CollectionImpl<CollectionT, SchematicT>(description, this, bases);\n    this._collectionCache.set(name, collection);\n    this._schematicCache.set(collection, new Map());\n\n    return collection;\n  }\n\n  private _createCollectionDescription(\n    name: string,\n    requester?: CollectionDescription<CollectionT>,\n    parentNames?: Set<string>,\n  ): [CollectionDescription<CollectionT>, Array<CollectionDescription<CollectionT>>] {\n    const description = this._host.createCollectionDescription(name, requester);\n    if (!description) {\n      throw new UnknownCollectionException(name);\n    }\n    if (parentNames && parentNames.has(description.name)) {\n      throw new CircularCollectionException(name);\n    }\n\n    const bases = new Array<CollectionDescription<CollectionT>>();\n    if (description.extends) {\n      parentNames = (parentNames || new Set<string>()).add(description.name);\n      for (const baseName of description.extends) {\n        const [base, baseBases] = this._createCollectionDescription(\n          baseName,\n          description,\n          new Set(parentNames),\n        );\n\n        bases.unshift(base, ...baseBases);\n      }\n    }\n\n    return [description, bases];\n  }\n\n  createContext(\n    schematic: Schematic<CollectionT, SchematicT>,\n    parent?: Partial<TypedSchematicContext<CollectionT, SchematicT>>,\n    executionOptions?: Partial<ExecutionOptions>,\n  ): TypedSchematicContext<CollectionT, SchematicT> {\n    // Check for inconsistencies.\n    if (parent && parent.engine && parent.engine !== this) {\n      throw new SchematicEngineConflictingException();\n    }\n\n    let interactive = true;\n    if (executionOptions && executionOptions.interactive != undefined) {\n      interactive = executionOptions.interactive;\n    } else if (parent && parent.interactive != undefined) {\n      interactive = parent.interactive;\n    }\n\n    let context: TypedSchematicContext<CollectionT, SchematicT> = {\n      debug: (parent && parent.debug) || false,\n      engine: this,\n      logger:\n        (parent && parent.logger && parent.logger.createChild(schematic.description.name)) ||\n        new logging.NullLogger(),\n      schematic,\n      strategy:\n        parent && parent.strategy !== undefined ? parent.strategy : this.defaultMergeStrategy,\n      interactive,\n      addTask,\n    };\n\n    const maybeNewContext = this._host.transformContext(context);\n    if (maybeNewContext) {\n      context = maybeNewContext;\n    }\n\n    const taskScheduler = new TaskScheduler(context);\n    const host = this._host;\n    this._taskSchedulers.push(taskScheduler);\n\n    function addTask<T extends object>(\n      task: TaskConfigurationGenerator<T>,\n      dependencies?: Array<TaskId>,\n    ): TaskId {\n      const config = task.toConfiguration();\n\n      if (!host.hasTaskExecutor(config.name)) {\n        throw new UnregisteredTaskException(config.name, schematic.description);\n      }\n\n      config.dependencies = config.dependencies || [];\n      if (dependencies) {\n        config.dependencies.unshift(...dependencies);\n      }\n\n      return taskScheduler.schedule(config);\n    }\n\n    return context;\n  }\n\n  createSchematic(\n    name: string,\n    collection: Collection<CollectionT, SchematicT>,\n    allowPrivate = false,\n  ): Schematic<CollectionT, SchematicT> {\n    const schematicMap = this._schematicCache.get(collection);\n\n    let schematic = schematicMap?.get(name);\n    if (schematic) {\n      return schematic;\n    }\n\n    let collectionDescription = collection.description;\n    let description = this._host.createSchematicDescription(name, collection.description);\n    if (!description) {\n      if (collection.baseDescriptions) {\n        for (const base of collection.baseDescriptions) {\n          description = this._host.createSchematicDescription(name, base);\n          if (description) {\n            collectionDescription = base;\n            break;\n          }\n        }\n      }\n      if (!description) {\n        // Report the error for the top level schematic collection\n        throw new UnknownSchematicException(name, collection.description);\n      }\n    }\n\n    if (description.private && !allowPrivate) {\n      throw new PrivateSchematicException(name, collection.description);\n    }\n\n    const factory = this._host.getSchematicRuleFactory(description, collectionDescription);\n    schematic = new SchematicImpl<CollectionT, SchematicT>(description, factory, collection, this);\n\n    schematicMap?.set(name, schematic);\n\n    return schematic;\n  }\n\n  listSchematicNames(\n    collection: Collection<CollectionT, SchematicT>,\n    includeHidden?: boolean,\n  ): string[] {\n    const names = this._host.listSchematicNames(collection.description, includeHidden);\n\n    if (collection.baseDescriptions) {\n      for (const base of collection.baseDescriptions) {\n        names.push(...this._host.listSchematicNames(base, includeHidden));\n      }\n    }\n\n    // remove duplicates\n    return [...new Set(names)].sort();\n  }\n\n  transformOptions<OptionT extends object, ResultT extends object>(\n    schematic: Schematic<CollectionT, SchematicT>,\n    options: OptionT,\n    context?: TypedSchematicContext<CollectionT, SchematicT>,\n  ): Observable<ResultT> {\n    return this._host.transformOptions<OptionT, ResultT>(schematic.description, options, context);\n  }\n\n  createSourceFromUrl(url: Url, context: TypedSchematicContext<CollectionT, SchematicT>): Source {\n    switch (url.protocol) {\n      case 'null:':\n        return () => new NullTree();\n      case 'empty:':\n        return () => empty();\n      default:\n        const hostSource = this._host.createSourceFromUrl(url, context);\n        if (!hostSource) {\n          throw new UnknownUrlSourceProtocol(url.toString());\n        }\n\n        return hostSource;\n    }\n  }\n\n  executePostTasks(): Observable<void> {\n    const executors = new Map<string, TaskExecutor>();\n\n    const taskObservable = observableFrom(this._taskSchedulers).pipe(\n      concatMap((scheduler) => scheduler.finalize()),\n      concatMap((task) => {\n        const { name, options } = task.configuration;\n\n        const executor = executors.get(name);\n        if (executor) {\n          return executor(options, task.context);\n        }\n\n        return this._host.createTaskExecutor(name).pipe(\n          concatMap((executor) => {\n            executors.set(name, executor);\n\n            return executor(options, task.context);\n          }),\n        );\n      }),\n    );\n\n    return taskObservable;\n  }\n}\n"]}