@angular-devkit/core 7.2.0-beta.0 → 7.2.0

package/src/experimental/jobs/simple-registry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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 { Observable } from 'rxjs';
+import { JsonValue } from '../../json';
+import { JobDescription, JobHandler, JobName, Registry } from './api';
+/**
+ * SimpleJobRegistry job registration options.
+ */
+export interface RegisterJobOptions extends Partial<JobDescription> {
+}
+/**
+ * A simple job registry that keep a map of JobName => JobHandler internally.
+ */
+export declare class SimpleJobRegistry<MinimumArgumentValueT extends JsonValue = JsonValue, MinimumInputValueT extends JsonValue = JsonValue, MinimumOutputValueT extends JsonValue = JsonValue> implements Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {
+    private _jobNames;
+    get<A extends MinimumArgumentValueT = MinimumArgumentValueT, I extends MinimumInputValueT = MinimumInputValueT, O extends MinimumOutputValueT = MinimumOutputValueT>(name: JobName): Observable<JobHandler<A, I, O> | null>;
+    /**
+     * Register a job handler. The name must be unique.
+     *
+     * @param name The name of the job.
+     * @param handler The function that will be called for the job.
+     * @param options An optional list of options to override the handler. {@see RegisterJobOptions}
+     */
+    register<A extends MinimumArgumentValueT, I extends MinimumInputValueT, O extends MinimumOutputValueT>(name: JobName, handler: JobHandler<A, I, O>, options?: RegisterJobOptions): void;
+    /**
+     * Register a job handler. The name must be unique.
+     *
+     * @param handler The function that will be called for the job.
+     * @param options An optional list of options to override the handler. {@see RegisterJobOptions}
+     */
+    register<ArgumentT extends JsonValue, InputT extends JsonValue, OutputT extends JsonValue>(handler: JobHandler<ArgumentT, InputT, OutputT>, options?: RegisterJobOptions & {
+        name: string;
+    }): void;
+    protected _register<ArgumentT extends JsonValue, InputT extends JsonValue, OutputT extends JsonValue>(name: JobName, handler: JobHandler<ArgumentT, InputT, OutputT>, options: RegisterJobOptions): void;
+    /**
+     * Returns the job names of all jobs.
+     */
+    getJobNames(): JobName[];
+}

package/src/experimental/jobs/simple-registry.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @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
+ */
+const rxjs_1 = require("rxjs");
+const json_1 = require("../../json");
+const api_1 = require("./api");
+const exception_1 = require("./exception");
+/**
+ * A simple job registry that keep a map of JobName => JobHandler internally.
+ */
+class SimpleJobRegistry {
+    constructor() {
+        this._jobNames = new Map();
+    }
+    get(name) {
+        return rxjs_1.of(this._jobNames.get(name) || null);
+    }
+    register(nameOrHandler, handlerOrOptions = {}, options = {}) {
+        // Switch on the arguments.
+        if (typeof nameOrHandler == 'string') {
+            if (!api_1.isJobHandler(handlerOrOptions)) {
+                // This is an error.
+                throw new TypeError('Expected a JobHandler as second argument.');
+            }
+            this._register(nameOrHandler, handlerOrOptions, options);
+        }
+        else if (api_1.isJobHandler(nameOrHandler)) {
+            if (typeof handlerOrOptions !== 'object') {
+                // This is an error.
+                throw new TypeError('Expected an object options as second argument.');
+            }
+            const name = options.name || nameOrHandler.jobDescription.name || handlerOrOptions.name;
+            if (name === undefined) {
+                throw new TypeError('Expected name to be a string.');
+            }
+            this._register(name, nameOrHandler, options);
+        }
+        else {
+            throw new TypeError('Unrecognized arguments.');
+        }
+    }
+    _register(name, handler, options) {
+        if (this._jobNames.has(name)) {
+            // We shouldn't allow conflicts.
+            throw new exception_1.JobNameAlreadyRegisteredException(name);
+        }
+        // Merge all fields with the ones in the handler (to make sure we respect the handler).
+        const argument = json_1.schema.mergeSchemas(handler.jobDescription.argument, options.argument);
+        const input = json_1.schema.mergeSchemas(handler.jobDescription.input, options.input);
+        const output = json_1.schema.mergeSchemas(handler.jobDescription.output, options.output);
+        // Create the job description.
+        const jobDescription = {
+            name,
+            argument,
+            output,
+            input,
+        };
+        this._jobNames.set(name, Object.assign(handler.bind(undefined), { jobDescription }));
+    }
+    /**
+     * Returns the job names of all jobs.
+     */
+    getJobNames() {
+        return [...this._jobNames.keys()];
+    }
+}
+exports.SimpleJobRegistry = SimpleJobRegistry;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-registry.js","sourceRoot":"./","sources":["packages/angular_devkit/core/src/experimental/jobs/simple-registry.ts"],"names":[],"mappings":";;AAAA;;;;;;GAMG;AACH,+BAAsC;AACtC,qCAA+C;AAC/C,+BAAoF;AACpF,2CAAgE;AAQhE;;GAEG;AACH,MAAa,iBAAiB;IAA9B;QAKU,cAAS,GAAG,IAAI,GAAG,EAGxB,CAAC;IAkHN,CAAC;IAhHC,GAAG,CAID,IAAa;QACb,OAAO,SAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAiC,IAAI,IAAI,CAAC,CAAC;IAC9E,CAAC;IA+BD,QAAQ,CACN,aAA+D,EAC/D,mBAAgF,EAAE,EAClF,UAA8B,EAAE;QAEhC,2BAA2B;QAC3B,IAAI,OAAO,aAAa,IAAI,QAAQ,EAAE;YACpC,IAAI,CAAC,kBAAY,CAAC,gBAAgB,CAAC,EAAE;gBACnC,oBAAoB;gBACpB,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC,CAAC;aAClE;YAED,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,gBAAgB,EAAE,OAAO,CAAC,CAAC;SAC1D;aAAM,IAAI,kBAAY,CAAC,aAAa,CAAC,EAAE;YACtC,IAAI,OAAO,gBAAgB,KAAK,QAAQ,EAAE;gBACxC,oBAAoB;gBACpB,MAAM,IAAI,SAAS,CAAC,gDAAgD,CAAC,CAAC;aACvE;YAED,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,aAAa,CAAC,cAAc,CAAC,IAAI,IAAI,gBAAgB,CAAC,IAAI,CAAC;YACxF,IAAI,IAAI,KAAK,SAAS,EAAE;gBACtB,MAAM,IAAI,SAAS,CAAC,+BAA+B,CAAC,CAAC;aACtD;YAED,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;SAC9C;aAAM;YACL,MAAM,IAAI,SAAS,CAAC,yBAAyB,CAAC,CAAC;SAChD;IACH,CAAC;IAES,SAAS,CAKjB,IAAa,EACb,OAA+C,EAC/C,OAA2B;QAE3B,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YAC5B,gCAAgC;YAChC,MAAM,IAAI,6CAAiC,CAAC,IAAI,CAAC,CAAC;SACnD;QAED,uFAAuF;QACvF,MAAM,QAAQ,GAAG,aAAM,CAAC,YAAY,CAClC,OAAO,CAAC,cAAc,CAAC,QAAQ,EAC/B,OAAO,CAAC,QAAQ,CACjB,CAAC;QACF,MAAM,KAAK,GAAG,aAAM,CAAC,YAAY,CAC/B,OAAO,CAAC,cAAc,CAAC,KAAK,EAC5B,OAAO,CAAC,KAAK,CACd,CAAC;QACF,MAAM,MAAM,GAAG,aAAM,CAAC,YAAY,CAChC,OAAO,CAAC,cAAc,CAAC,MAAM,EAC7B,OAAO,CAAC,MAAM,CACf,CAAC;QAEF,8BAA8B;QAC9B,MAAM,cAAc,GAAmB;YACrC,IAAI;YACJ,QAAQ;YACR,MAAM;YACN,KAAK;SACN,CAAC;QAEF,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;IACvF,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;IACpC,CAAC;CACF;AA1HD,8CA0HC","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 */\nimport { Observable, of } from 'rxjs';\nimport { JsonValue, schema } from '../../json';\nimport { JobDescription, JobHandler, JobName, Registry, isJobHandler } from './api';\nimport { JobNameAlreadyRegisteredException } from './exception';\n\n\n/**\n * SimpleJobRegistry job registration options.\n */\nexport interface RegisterJobOptions extends Partial<JobDescription> {}\n\n/**\n * A simple job registry that keep a map of JobName => JobHandler internally.\n */\nexport class SimpleJobRegistry<\n  MinimumArgumentValueT extends JsonValue = JsonValue,\n  MinimumInputValueT extends JsonValue = JsonValue,\n  MinimumOutputValueT extends JsonValue = JsonValue,\n> implements Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {\n  private _jobNames = new Map<\n    JobName,\n    JobHandler<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT>\n  >();\n\n  get<\n    A extends MinimumArgumentValueT = MinimumArgumentValueT,\n    I extends MinimumInputValueT = MinimumInputValueT,\n    O extends MinimumOutputValueT = MinimumOutputValueT,\n  >(name: JobName): Observable<JobHandler<A, I, O> | null> {\n    return of(this._jobNames.get(name) as (JobHandler<A, I, O> | null) || null);\n  }\n\n  /**\n   * Register a job handler. The name must be unique.\n   *\n   * @param name The name of the job.\n   * @param handler The function that will be called for the job.\n   * @param options An optional list of options to override the handler. {@see RegisterJobOptions}\n   */\n  register<\n    A extends MinimumArgumentValueT,\n    I extends MinimumInputValueT,\n    O extends MinimumOutputValueT,\n  >(\n    name: JobName,\n    handler: JobHandler<A, I, O>,\n    options?: RegisterJobOptions,\n  ): void;\n\n  /**\n   * Register a job handler. The name must be unique.\n   *\n   * @param handler The function that will be called for the job.\n   * @param options An optional list of options to override the handler. {@see RegisterJobOptions}\n   */\n  register<ArgumentT extends JsonValue, InputT extends JsonValue, OutputT extends JsonValue>(\n    handler: JobHandler<ArgumentT, InputT, OutputT>,\n    // This version MUST contain a name.\n    options?: RegisterJobOptions & { name: string },\n  ): void;\n\n  register<ArgumentT extends JsonValue, InputT extends JsonValue, OutputT extends JsonValue>(\n    nameOrHandler: JobName | JobHandler<ArgumentT, InputT, OutputT>,\n    handlerOrOptions: JobHandler<ArgumentT, InputT, OutputT> | RegisterJobOptions = {},\n    options: RegisterJobOptions = {},\n  ): void {\n    // Switch on the arguments.\n    if (typeof nameOrHandler == 'string') {\n      if (!isJobHandler(handlerOrOptions)) {\n        // This is an error.\n        throw new TypeError('Expected a JobHandler as second argument.');\n      }\n\n      this._register(nameOrHandler, handlerOrOptions, options);\n    } else if (isJobHandler(nameOrHandler)) {\n      if (typeof handlerOrOptions !== 'object') {\n        // This is an error.\n        throw new TypeError('Expected an object options as second argument.');\n      }\n\n      const name = options.name || nameOrHandler.jobDescription.name || handlerOrOptions.name;\n      if (name === undefined) {\n        throw new TypeError('Expected name to be a string.');\n      }\n\n      this._register(name, nameOrHandler, options);\n    } else {\n      throw new TypeError('Unrecognized arguments.');\n    }\n  }\n\n  protected _register<\n    ArgumentT extends JsonValue,\n    InputT extends JsonValue,\n    OutputT extends JsonValue,\n  >(\n    name: JobName,\n    handler: JobHandler<ArgumentT, InputT, OutputT>,\n    options: RegisterJobOptions,\n  ): void {\n    if (this._jobNames.has(name)) {\n      // We shouldn't allow conflicts.\n      throw new JobNameAlreadyRegisteredException(name);\n    }\n\n    // Merge all fields with the ones in the handler (to make sure we respect the handler).\n    const argument = schema.mergeSchemas(\n      handler.jobDescription.argument,\n      options.argument,\n    );\n    const input = schema.mergeSchemas(\n      handler.jobDescription.input,\n      options.input,\n    );\n    const output = schema.mergeSchemas(\n      handler.jobDescription.output,\n      options.output,\n    );\n\n    // Create the job description.\n    const jobDescription: JobDescription = {\n      name,\n      argument,\n      output,\n      input,\n    };\n\n    this._jobNames.set(name, Object.assign(handler.bind(undefined), { jobDescription }));\n  }\n\n  /**\n   * Returns the job names of all jobs.\n   */\n  getJobNames(): JobName[] {\n    return [...this._jobNames.keys()];\n  }\n}\n"]}

package/src/experimental/jobs/simple-scheduler.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @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 { Observable } from 'rxjs';
+import { JsonValue, schema } from '../../json';
+import { Job, JobDescription, JobName, Registry, ScheduleJobOptions, Scheduler } from './api';
+export declare class JobInboundMessageSchemaValidationError extends schema.SchemaValidationException {
+    constructor(errors?: schema.SchemaValidatorError[]);
+}
+export declare class JobOutputSchemaValidationError extends schema.SchemaValidationException {
+    constructor(errors?: schema.SchemaValidatorError[]);
+}
+/**
+ * Simple scheduler. Should be the base of all registries and schedulers.
+ */
+export declare class SimpleScheduler<MinimumArgumentT extends JsonValue = JsonValue, MinimumInputT extends JsonValue = JsonValue, MinimumOutputT extends JsonValue = JsonValue> implements Scheduler<MinimumArgumentT, MinimumInputT, MinimumOutputT> {
+    protected _jobRegistry: Registry<MinimumArgumentT, MinimumInputT, MinimumOutputT>;
+    protected _schemaRegistry: schema.SchemaRegistry;
+    private _internalJobDescriptionMap;
+    private _queue;
+    private _pauseCounter;
+    constructor(_jobRegistry: Registry<MinimumArgumentT, MinimumInputT, MinimumOutputT>, _schemaRegistry?: schema.SchemaRegistry);
+    private _getInternalDescription;
+    /**
+     * Get a job description for a named job.
+     *
+     * @param name The name of the job.
+     * @returns A description, or null if the job is not registered.
+     */
+    getDescription(name: JobName): Observable<JobDescription | null>;
+    /**
+     * Returns true if the job name has been registered.
+     * @param name The name of the job.
+     * @returns True if the job exists, false otherwise.
+     */
+    has(name: JobName): Observable<boolean>;
+    /**
+     * Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be
+     * used to resume execution. If multiple `pause()` were called, all their resume functions must
+     * be called before the Scheduler actually starts new jobs. Additional calls to the same resume
+     * function will have no effect.
+     *
+     * Jobs already running are NOT paused. This is pausing the scheduler only.
+     */
+    pause(): () => void;
+    /**
+     * Schedule a job to be run, using its name.
+     * @param name The name of job to be run.
+     * @param argument The argument to send to the job when starting it.
+     * @param options Scheduling options.
+     * @returns The Job being run.
+     */
+    schedule<A extends MinimumArgumentT, I extends MinimumInputT, O extends MinimumOutputT>(name: JobName, argument: A, options?: ScheduleJobOptions): Job<A, I, O>;
+    /**
+     * Filter messages.
+     * @private
+     */
+    private _filterJobOutboundMessages;
+    /**
+     * Return a new state. This is just to simplify the reading of the _createJob method.
+     * @private
+     */
+    private _updateState;
+    /**
+     * Create the job.
+     * @private
+     */
+    private _createJob;
+    protected _scheduleJob<A extends MinimumArgumentT, I extends MinimumInputT, O extends MinimumOutputT>(name: JobName, argument: A, options: ScheduleJobOptions, waitable: Observable<never>): Job<A, I, O>;
+}

package/src/experimental/jobs/simple-scheduler.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @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
+ */
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const json_1 = require("../../json");
+const logger_1 = require("../../logger");
+const api_1 = require("./api");
+const exception_1 = require("./exception");
+class JobInboundMessageSchemaValidationError extends json_1.schema.SchemaValidationException {
+    constructor(errors) {
+        super(errors, 'Job Inbound Message failed to validate. Errors: ');
+    }
+}
+exports.JobInboundMessageSchemaValidationError = JobInboundMessageSchemaValidationError;
+class JobOutputSchemaValidationError extends json_1.schema.SchemaValidationException {
+    constructor(errors) {
+        super(errors, 'Job Output failed to validate. Errors: ');
+    }
+}
+exports.JobOutputSchemaValidationError = JobOutputSchemaValidationError;
+function _jobShare() {
+    // This is the same code as a `shareReplay()` operator, but uses a dumber Subject rather than a
+    // ReplaySubject.
+    return (source) => {
+        let refCount = 0;
+        let subject;
+        let hasError = false;
+        let isComplete = false;
+        let subscription;
+        return new rxjs_1.Observable(subscriber => {
+            let innerSub;
+            refCount++;
+            if (!subject) {
+                subject = new rxjs_1.Subject();
+                innerSub = subject.subscribe(subscriber);
+                subscription = source.subscribe({
+                    next(value) { subject.next(value); },
+                    error(err) {
+                        hasError = true;
+                        subject.error(err);
+                    },
+                    complete() {
+                        isComplete = true;
+                        subject.complete();
+                    },
+                });
+            }
+            else {
+                innerSub = subject.subscribe(subscriber);
+            }
+            return () => {
+                refCount--;
+                innerSub.unsubscribe();
+                if (subscription && refCount === 0 && (isComplete || hasError)) {
+                    subscription.unsubscribe();
+                }
+            };
+        });
+    };
+}
+/**
+ * Simple scheduler. Should be the base of all registries and schedulers.
+ */
+class SimpleScheduler {
+    constructor(_jobRegistry, _schemaRegistry = new json_1.schema.CoreSchemaRegistry()) {
+        this._jobRegistry = _jobRegistry;
+        this._schemaRegistry = _schemaRegistry;
+        this._internalJobDescriptionMap = new Map();
+        this._queue = [];
+        this._pauseCounter = 0;
+    }
+    _getInternalDescription(name) {
+        const maybeHandler = this._internalJobDescriptionMap.get(name);
+        if (maybeHandler !== undefined) {
+            return rxjs_1.of(maybeHandler);
+        }
+        const handler = this._jobRegistry.get(name);
+        return handler.pipe(operators_1.switchMap(handler => {
+            if (handler === null) {
+                return rxjs_1.of(null);
+            }
+            const description = {
+                name,
+                argument: handler.jobDescription.argument || true,
+                input: handler.jobDescription.input || true,
+                output: handler.jobDescription.output || true,
+                channels: handler.jobDescription.channels || {},
+            };
+            const handlerWithExtra = Object.assign(handler.bind(undefined), {
+                jobDescription: description,
+                argumentV: this._schemaRegistry.compile(description.argument).pipe(operators_1.shareReplay(1)),
+                inputV: this._schemaRegistry.compile(description.input).pipe(operators_1.shareReplay(1)),
+                outputV: this._schemaRegistry.compile(description.output).pipe(operators_1.shareReplay(1)),
+            });
+            this._internalJobDescriptionMap.set(name, handlerWithExtra);
+            return rxjs_1.of(handlerWithExtra);
+        }));
+    }
+    /**
+     * Get a job description for a named job.
+     *
+     * @param name The name of the job.
+     * @returns A description, or null if the job is not registered.
+     */
+    getDescription(name) {
+        return rxjs_1.concat(this._getInternalDescription(name).pipe(operators_1.map(x => x && x.jobDescription)), rxjs_1.of(null)).pipe(operators_1.first());
+    }
+    /**
+     * Returns true if the job name has been registered.
+     * @param name The name of the job.
+     * @returns True if the job exists, false otherwise.
+     */
+    has(name) {
+        return this.getDescription(name).pipe(operators_1.map(x => x !== null));
+    }
+    /**
+     * Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be
+     * used to resume execution. If multiple `pause()` were called, all their resume functions must
+     * be called before the Scheduler actually starts new jobs. Additional calls to the same resume
+     * function will have no effect.
+     *
+     * Jobs already running are NOT paused. This is pausing the scheduler only.
+     */
+    pause() {
+        let called = false;
+        this._pauseCounter++;
+        return () => {
+            if (!called) {
+                called = true;
+                if (--this._pauseCounter == 0) {
+                    // Resume the queue.
+                    const q = this._queue;
+                    this._queue = [];
+                    q.forEach(fn => fn());
+                }
+            }
+        };
+    }
+    /**
+     * Schedule a job to be run, using its name.
+     * @param name The name of job to be run.
+     * @param argument The argument to send to the job when starting it.
+     * @param options Scheduling options.
+     * @returns The Job being run.
+     */
+    schedule(name, argument, options) {
+        if (this._pauseCounter > 0) {
+            const waitable = new rxjs_1.Subject();
+            this._queue.push(() => waitable.complete());
+            return this._scheduleJob(name, argument, options || {}, waitable);
+        }
+        return this._scheduleJob(name, argument, options || {}, rxjs_1.EMPTY);
+    }
+    /**
+     * Filter messages.
+     * @private
+     */
+    _filterJobOutboundMessages(message, state) {
+        switch (message.kind) {
+            case api_1.JobOutboundMessageKind.OnReady:
+                return state == api_1.JobState.Queued;
+            case api_1.JobOutboundMessageKind.Start:
+                return state == api_1.JobState.Ready;
+            case api_1.JobOutboundMessageKind.End:
+                return state == api_1.JobState.Started || state == api_1.JobState.Ready;
+        }
+        return true;
+    }
+    /**
+     * Return a new state. This is just to simplify the reading of the _createJob method.
+     * @private
+     */
+    _updateState(message, state) {
+        switch (message.kind) {
+            case api_1.JobOutboundMessageKind.OnReady:
+                return api_1.JobState.Ready;
+            case api_1.JobOutboundMessageKind.Start:
+                return api_1.JobState.Started;
+            case api_1.JobOutboundMessageKind.End:
+                return api_1.JobState.Ended;
+        }
+        return state;
+    }
+    /**
+     * Create the job.
+     * @private
+     */
+    _createJob(name, argument, handler, inboundBus, outboundBus, options) {
+        const schemaRegistry = this._schemaRegistry;
+        const channelsSubject = new Map();
+        const channels = new Map();
+        let state = api_1.JobState.Queued;
+        let pingId = 0;
+        const logger = options.logger ? options.logger.createChild('job') : new logger_1.NullLogger();
+        // Create the input channel by having a filter.
+        const input = new rxjs_1.Subject();
+        input.pipe(operators_1.switchMap(message => handler.pipe(operators_1.switchMap(handler => {
+            if (handler === null) {
+                throw new exception_1.JobDoesNotExistException(name);
+            }
+            else {
+                return handler.inputV.pipe(operators_1.switchMap(validate => validate(message)));
+            }
+        }))), operators_1.filter(result => result.success), operators_1.map(result => result.data)).subscribe(value => inboundBus.next({ kind: api_1.JobInboundMessageKind.Input, value }));
+        outboundBus = rxjs_1.concat(outboundBus, 
+        // Add an End message at completion. This will be filtered out if the job actually send an
+        // End.
+        handler.pipe(operators_1.switchMap(handler => {
+            if (handler) {
+                return rxjs_1.of({
+                    kind: api_1.JobOutboundMessageKind.End, description: handler.jobDescription,
+                });
+            }
+            else {
+                return rxjs_1.EMPTY;
+            }
+        }))).pipe(operators_1.filter(message => this._filterJobOutboundMessages(message, state)), 
+        // Update internal logic and Job<> members.
+        operators_1.tap(message => {
+            // Update the state.
+            state = this._updateState(message, state);
+            switch (message.kind) {
+                case api_1.JobOutboundMessageKind.Log:
+                    logger.next(message.entry);
+                    break;
+                case api_1.JobOutboundMessageKind.ChannelCreate: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    // If it doesn't exist or it's closed on the other end.
+                    if (!maybeSubject) {
+                        const s = new rxjs_1.Subject();
+                        channelsSubject.set(message.name, s);
+                        channels.set(message.name, s.asObservable());
+                    }
+                    break;
+                }
+                case api_1.JobOutboundMessageKind.ChannelMessage: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    if (maybeSubject) {
+                        maybeSubject.next(message.message);
+                    }
+                    break;
+                }
+                case api_1.JobOutboundMessageKind.ChannelComplete: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    if (maybeSubject) {
+                        maybeSubject.complete();
+                        channelsSubject.delete(message.name);
+                    }
+                    break;
+                }
+                case api_1.JobOutboundMessageKind.ChannelError: {
+                    const maybeSubject = channelsSubject.get(message.name);
+                    if (maybeSubject) {
+                        maybeSubject.error(message.error);
+                        channelsSubject.delete(message.name);
+                    }
+                    break;
+                }
+            }
+        }, () => {
+            state = api_1.JobState.Errored;
+        }), 
+        // Do output validation (might include default values so this might have side
+        // effects). We keep all messages in order.
+        operators_1.concatMap(message => {
+            if (message.kind !== api_1.JobOutboundMessageKind.Output) {
+                return rxjs_1.of(message);
+            }
+            return handler.pipe(operators_1.switchMap(handler => {
+                if (handler === null) {
+                    throw new exception_1.JobDoesNotExistException(name);
+                }
+                else {
+                    return handler.outputV.pipe(operators_1.switchMap(validate => validate(message.value)), operators_1.switchMap(output => {
+                        if (!output.success) {
+                            throw new JobOutputSchemaValidationError(output.errors);
+                        }
+                        return rxjs_1.of(Object.assign({}, message, { output: output.data }));
+                    }));
+                }
+            }));
+        }), _jobShare());
+        const output = outboundBus.pipe(operators_1.filter(x => x.kind == api_1.JobOutboundMessageKind.Output), operators_1.map((x) => x.value), operators_1.shareReplay(1));
+        // Return the Job.
+        return {
+            get state() { return state; },
+            argument,
+            description: handler.pipe(operators_1.switchMap(handler => {
+                if (handler === null) {
+                    throw new exception_1.JobDoesNotExistException(name);
+                }
+                else {
+                    return rxjs_1.of(handler.jobDescription);
+                }
+            })),
+            output,
+            getChannel(name, schema = true) {
+                let maybeObservable = channels.get(name);
+                if (!maybeObservable) {
+                    const s = new rxjs_1.Subject();
+                    channelsSubject.set(name, s);
+                    channels.set(name, s.asObservable());
+                    maybeObservable = s.asObservable();
+                }
+                return maybeObservable.pipe(
+                // Keep the order of messages.
+                operators_1.concatMap(message => {
+                    return schemaRegistry.compile(schema).pipe(operators_1.switchMap(validate => validate(message)), operators_1.filter(x => x.success), operators_1.map(x => x.data));
+                }));
+            },
+            ping() {
+                const id = pingId++;
+                inboundBus.next({ kind: api_1.JobInboundMessageKind.Ping, id });
+                return outboundBus.pipe(operators_1.filter(x => x.kind === api_1.JobOutboundMessageKind.Pong && x.id == id), operators_1.first(), operators_1.ignoreElements());
+            },
+            stop() {
+                inboundBus.next({ kind: api_1.JobInboundMessageKind.Stop });
+            },
+            input,
+            inboundBus,
+            outboundBus,
+        };
+    }
+    _scheduleJob(name, argument, options, waitable) {
+        // Get handler first, since this can error out if there's no handler for the job name.
+        const handler = this._getInternalDescription(name);
+        const optionsDeps = (options && options.dependencies) || [];
+        const dependencies = Array.isArray(optionsDeps) ? optionsDeps : [optionsDeps];
+        const inboundBus = new rxjs_1.Subject();
+        const outboundBus = rxjs_1.concat(
+        // Wait for dependencies, make sure to not report messages from dependencies. Subscribe to
+        // all dependencies at the same time so they run concurrently.
+        rxjs_1.merge(...dependencies.map(x => x.outboundBus)).pipe(operators_1.ignoreElements()), 
+        // Wait for pause() to clear (if necessary).
+        waitable, rxjs_1.from(handler).pipe(operators_1.switchMap(handler => new rxjs_1.Observable((subscriber) => {
+            if (!handler) {
+                throw new exception_1.JobDoesNotExistException(name);
+            }
+            // Validate the argument.
+            return handler.argumentV.pipe(operators_1.switchMap(validate => validate(argument)), operators_1.switchMap(output => {
+                if (!output.success) {
+                    throw new JobInboundMessageSchemaValidationError(output.errors);
+                }
+                const argument = output.data;
+                const description = handler.jobDescription;
+                subscriber.next({ kind: api_1.JobOutboundMessageKind.OnReady, description });
+                const context = {
+                    description,
+                    dependencies: [...dependencies],
+                    inboundBus: inboundBus.asObservable(),
+                    scheduler: this,
+                };
+                return handler(argument, context);
+            })).subscribe(subscriber);
+        }))));
+        return this._createJob(name, argument, handler, inboundBus, outboundBus, options);
+    }
+}
+exports.SimpleScheduler = SimpleScheduler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-scheduler.js","sourceRoot":"./","sources":["packages/angular_devkit/core/src/experimental/jobs/simple-scheduler.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 */\nimport {\n  EMPTY,\n  MonoTypeOperatorFunction,\n  Observable,\n  Observer,\n  Subject,\n  Subscription,\n  concat,\n  from,\n  merge,\n  of,\n} from 'rxjs';\nimport {\n  concatMap,\n  filter,\n  first,\n  ignoreElements,\n  map,\n  shareReplay,\n  switchMap,\n  tap,\n} from 'rxjs/operators';\nimport { JsonValue, schema } from '../../json';\nimport { NullLogger } from '../../logger';\nimport {\n  Job,\n  JobDescription,\n  JobHandler,\n  JobInboundMessage,\n  JobInboundMessageKind,\n  JobName,\n  JobOutboundMessage,\n  JobOutboundMessageKind,\n  JobOutboundMessageOutput,\n  JobState,\n  Registry,\n  ScheduleJobOptions,\n  Scheduler,\n} from './api';\nimport { JobDoesNotExistException } from './exception';\n\n\nexport class JobInboundMessageSchemaValidationError extends schema.SchemaValidationException {\n  constructor(errors?: schema.SchemaValidatorError[]) {\n    super(errors, 'Job Inbound Message failed to validate. Errors: ');\n  }\n}\nexport class JobOutputSchemaValidationError extends schema.SchemaValidationException {\n  constructor(errors?: schema.SchemaValidatorError[]) {\n    super(errors, 'Job Output failed to validate. Errors: ');\n  }\n}\n\n\ninterface JobHandlerWithExtra extends JobHandler<JsonValue, JsonValue, JsonValue> {\n  jobDescription: JobDescription;\n\n  argumentV: Observable<schema.SchemaValidator>;\n  outputV: Observable<schema.SchemaValidator>;\n  inputV: Observable<schema.SchemaValidator>;\n}\n\n\nfunction _jobShare<T>(): MonoTypeOperatorFunction<T> {\n  // This is the same code as a `shareReplay()` operator, but uses a dumber Subject rather than a\n  // ReplaySubject.\n  return (source: Observable<T>): Observable<T> => {\n    let refCount = 0;\n    let subject: Subject<T>;\n    let hasError = false;\n    let isComplete = false;\n    let subscription: Subscription;\n\n    return new Observable<T>(subscriber => {\n      let innerSub: Subscription;\n      refCount++;\n      if (!subject) {\n        subject = new Subject<T>();\n\n        innerSub = subject.subscribe(subscriber);\n        subscription = source.subscribe({\n          next(value) { subject.next(value); },\n          error(err) {\n            hasError = true;\n            subject.error(err);\n          },\n          complete() {\n            isComplete = true;\n            subject.complete();\n          },\n        });\n      } else {\n        innerSub = subject.subscribe(subscriber);\n      }\n\n      return () => {\n        refCount--;\n        innerSub.unsubscribe();\n        if (subscription && refCount === 0 && (isComplete || hasError)) {\n          subscription.unsubscribe();\n        }\n      };\n    });\n  };\n}\n\n\n/**\n * Simple scheduler. Should be the base of all registries and schedulers.\n */\nexport class SimpleScheduler<\n  MinimumArgumentT extends JsonValue = JsonValue,\n  MinimumInputT extends JsonValue = JsonValue,\n  MinimumOutputT extends JsonValue = JsonValue,\n> implements Scheduler<MinimumArgumentT, MinimumInputT, MinimumOutputT> {\n  private _internalJobDescriptionMap = new Map<JobName, JobHandlerWithExtra>();\n  private _queue: (() => void)[] = [];\n  private _pauseCounter = 0;\n\n  constructor(\n    protected _jobRegistry: Registry<MinimumArgumentT, MinimumInputT, MinimumOutputT>,\n    protected _schemaRegistry: schema.SchemaRegistry = new schema.CoreSchemaRegistry(),\n  ) {}\n\n  private _getInternalDescription(name: JobName): Observable<JobHandlerWithExtra | null> {\n    const maybeHandler = this._internalJobDescriptionMap.get(name);\n    if (maybeHandler !== undefined) {\n      return of(maybeHandler);\n    }\n\n    const handler = this._jobRegistry.get<MinimumArgumentT, MinimumInputT, MinimumOutputT>(name);\n\n    return handler.pipe(\n      switchMap(handler => {\n        if (handler === null) {\n          return of(null);\n        }\n\n        const description: JobDescription = {\n          name,\n          argument: handler.jobDescription.argument || true,\n          input: handler.jobDescription.input || true,\n          output: handler.jobDescription.output || true,\n          channels: handler.jobDescription.channels || {},\n        };\n\n        const handlerWithExtra = Object.assign(handler.bind(undefined), {\n          jobDescription: description,\n          argumentV: this._schemaRegistry.compile(description.argument).pipe(shareReplay(1)),\n          inputV: this._schemaRegistry.compile(description.input).pipe(shareReplay(1)),\n          outputV: this._schemaRegistry.compile(description.output).pipe(shareReplay(1)),\n        });\n        this._internalJobDescriptionMap.set(name, handlerWithExtra);\n\n        return of(handlerWithExtra);\n      }),\n    );\n  }\n\n  /**\n   * Get a job description for a named job.\n   *\n   * @param name The name of the job.\n   * @returns A description, or null if the job is not registered.\n   */\n  getDescription(name: JobName) {\n    return concat(\n      this._getInternalDescription(name).pipe(map(x => x && x.jobDescription)),\n      of(null),\n    ).pipe(\n      first(),\n    );\n  }\n\n  /**\n   * Returns true if the job name has been registered.\n   * @param name The name of the job.\n   * @returns True if the job exists, false otherwise.\n   */\n  has(name: JobName) {\n    return this.getDescription(name).pipe(\n      map(x => x !== null),\n    );\n  }\n\n  /**\n   * Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be\n   * used to resume execution. If multiple `pause()` were called, all their resume functions must\n   * be called before the Scheduler actually starts new jobs. Additional calls to the same resume\n   * function will have no effect.\n   *\n   * Jobs already running are NOT paused. This is pausing the scheduler only.\n   */\n  pause() {\n    let called = false;\n    this._pauseCounter++;\n\n    return () => {\n      if (!called) {\n        called = true;\n        if (--this._pauseCounter == 0) {\n          // Resume the queue.\n          const q = this._queue;\n          this._queue = [];\n          q.forEach(fn => fn());\n        }\n      }\n    };\n  }\n\n  /**\n   * Schedule a job to be run, using its name.\n   * @param name The name of job to be run.\n   * @param argument The argument to send to the job when starting it.\n   * @param options Scheduling options.\n   * @returns The Job being run.\n   */\n  schedule<A extends MinimumArgumentT, I extends MinimumInputT, O extends MinimumOutputT>(\n    name: JobName,\n    argument: A,\n    options?: ScheduleJobOptions,\n  ): Job<A, I, O> {\n    if (this._pauseCounter > 0) {\n      const waitable = new Subject<never>();\n      this._queue.push(() => waitable.complete());\n\n      return this._scheduleJob<A, I, O>(name, argument, options || {}, waitable);\n    }\n\n    return this._scheduleJob<A, I, O>(name, argument, options || {}, EMPTY);\n  }\n\n  /**\n   * Filter messages.\n   * @private\n   */\n  private _filterJobOutboundMessages<O extends MinimumOutputT>(\n    message: JobOutboundMessage<O>,\n    state: JobState,\n  ) {\n    switch (message.kind) {\n      case JobOutboundMessageKind.OnReady:\n        return state == JobState.Queued;\n      case JobOutboundMessageKind.Start:\n        return state == JobState.Ready;\n\n      case JobOutboundMessageKind.End:\n        return state == JobState.Started || state == JobState.Ready;\n    }\n\n    return true;\n  }\n\n  /**\n   * Return a new state. This is just to simplify the reading of the _createJob method.\n   * @private\n   */\n  private _updateState<O extends MinimumOutputT>(\n    message: JobOutboundMessage<O>,\n    state: JobState,\n  ): JobState {\n    switch (message.kind) {\n      case JobOutboundMessageKind.OnReady:\n        return JobState.Ready;\n      case JobOutboundMessageKind.Start:\n        return JobState.Started;\n      case JobOutboundMessageKind.End:\n        return JobState.Ended;\n    }\n\n    return state;\n  }\n\n  /**\n   * Create the job.\n   * @private\n   */\n  private _createJob<A extends MinimumArgumentT, I extends MinimumInputT, O extends MinimumOutputT>(\n    name: JobName,\n    argument: A,\n    handler: Observable<JobHandlerWithExtra | null>,\n    inboundBus: Observer<JobInboundMessage<I>>,\n    outboundBus: Observable<JobOutboundMessage<O>>,\n    options: ScheduleJobOptions,\n  ): Job<A, I, O> {\n    const schemaRegistry = this._schemaRegistry;\n\n    const channelsSubject = new Map<string, Subject<JsonValue>>();\n    const channels = new Map<string, Observable<JsonValue>>();\n\n    let state = JobState.Queued;\n    let pingId = 0;\n\n    const logger = options.logger ? options.logger.createChild('job') : new NullLogger();\n\n    // Create the input channel by having a filter.\n    const input = new Subject<JsonValue>();\n    input.pipe(\n      switchMap(message => handler.pipe(\n        switchMap(handler => {\n          if (handler === null) {\n            throw new JobDoesNotExistException(name);\n          } else {\n            return handler.inputV.pipe(\n              switchMap(validate => validate(message)),\n            );\n          }\n        }),\n      )),\n      filter(result => result.success),\n      map(result => result.data as I),\n    ).subscribe(\n      value => inboundBus.next({ kind: JobInboundMessageKind.Input, value }),\n    );\n\n    outboundBus = concat(\n      outboundBus,\n      // Add an End message at completion. This will be filtered out if the job actually send an\n      // End.\n      handler.pipe(switchMap(handler => {\n        if (handler) {\n          return of<JobOutboundMessage<O>>({\n            kind: JobOutboundMessageKind.End, description: handler.jobDescription,\n          });\n        } else {\n          return EMPTY as Observable<JobOutboundMessage<O>>;\n        }\n      })),\n    ).pipe(\n      filter(message => this._filterJobOutboundMessages(message, state)),\n      // Update internal logic and Job<> members.\n      tap(message => {\n        // Update the state.\n        state = this._updateState(message, state);\n\n        switch (message.kind) {\n          case JobOutboundMessageKind.Log:\n            logger.next(message.entry);\n            break;\n\n          case JobOutboundMessageKind.ChannelCreate: {\n            const maybeSubject = channelsSubject.get(message.name);\n            // If it doesn't exist or it's closed on the other end.\n            if (!maybeSubject) {\n              const s = new Subject<JsonValue>();\n              channelsSubject.set(message.name, s);\n              channels.set(message.name, s.asObservable());\n            }\n            break;\n          }\n\n          case JobOutboundMessageKind.ChannelMessage: {\n            const maybeSubject = channelsSubject.get(message.name);\n            if (maybeSubject) {\n              maybeSubject.next(message.message);\n            }\n            break;\n          }\n\n          case JobOutboundMessageKind.ChannelComplete: {\n            const maybeSubject = channelsSubject.get(message.name);\n            if (maybeSubject) {\n              maybeSubject.complete();\n              channelsSubject.delete(message.name);\n            }\n            break;\n          }\n\n          case JobOutboundMessageKind.ChannelError: {\n            const maybeSubject = channelsSubject.get(message.name);\n            if (maybeSubject) {\n              maybeSubject.error(message.error);\n              channelsSubject.delete(message.name);\n            }\n            break;\n          }\n        }\n      }, () => {\n        state = JobState.Errored;\n      }),\n\n      // Do output validation (might include default values so this might have side\n      // effects). We keep all messages in order.\n      concatMap(message => {\n        if (message.kind !== JobOutboundMessageKind.Output) {\n          return of(message);\n        }\n\n        return handler.pipe(\n          switchMap(handler => {\n            if (handler === null) {\n              throw new JobDoesNotExistException(name);\n            } else {\n              return handler.outputV.pipe(\n                switchMap(validate => validate(message.value)),\n                switchMap(output => {\n                  if (!output.success) {\n                    throw new JobOutputSchemaValidationError(output.errors);\n                  }\n\n                  return of({\n                    ...message,\n                    output: output.data as O,\n                  } as JobOutboundMessageOutput<O>);\n                }),\n              );\n            }\n          }),\n        ) as Observable<JobOutboundMessage<O>>;\n      }),\n      _jobShare(),\n    );\n\n    const output = outboundBus.pipe(\n      filter(x => x.kind == JobOutboundMessageKind.Output),\n      map((x: JobOutboundMessageOutput<O>) => x.value),\n      shareReplay(1),\n    );\n\n    // Return the Job.\n    return {\n      get state() { return state; },\n      argument,\n      description: handler.pipe(\n        switchMap(handler => {\n          if (handler === null) {\n            throw new JobDoesNotExistException(name);\n          } else {\n            return of(handler.jobDescription);\n          }\n        }),\n      ),\n      output,\n      getChannel<T extends JsonValue>(\n        name: JobName,\n        schema: schema.JsonSchema = true,\n      ): Observable<T> {\n        let maybeObservable = channels.get(name);\n        if (!maybeObservable) {\n          const s = new Subject<T>();\n          channelsSubject.set(name, s);\n          channels.set(name, s.asObservable());\n\n          maybeObservable = s.asObservable();\n        }\n\n        return maybeObservable.pipe(\n          // Keep the order of messages.\n          concatMap(\n            message => {\n              return schemaRegistry.compile(schema).pipe(\n                switchMap(validate => validate(message)),\n                filter(x => x.success),\n                map(x => x.data as T),\n              );\n            },\n          ),\n        );\n      },\n      ping() {\n        const id = pingId++;\n        inboundBus.next({ kind: JobInboundMessageKind.Ping, id });\n\n        return outboundBus.pipe(\n          filter(x => x.kind === JobOutboundMessageKind.Pong && x.id == id),\n          first(),\n          ignoreElements(),\n        );\n      },\n      stop() {\n        inboundBus.next({ kind: JobInboundMessageKind.Stop });\n      },\n      input,\n      inboundBus,\n      outboundBus,\n    };\n  }\n\n  protected _scheduleJob<\n    A extends MinimumArgumentT,\n    I extends MinimumInputT,\n    O extends MinimumOutputT,\n  >(\n    name: JobName,\n    argument: A,\n    options: ScheduleJobOptions,\n    waitable: Observable<never>,\n  ): Job<A, I, O> {\n    // Get handler first, since this can error out if there's no handler for the job name.\n    const handler = this._getInternalDescription(name);\n\n    const optionsDeps = (options && options.dependencies) || [];\n    const dependencies = Array.isArray(optionsDeps) ? optionsDeps : [optionsDeps];\n\n    const inboundBus = new Subject<JobInboundMessage<I>>();\n    const outboundBus = concat(\n      // Wait for dependencies, make sure to not report messages from dependencies. Subscribe to\n      // all dependencies at the same time so they run concurrently.\n      merge(...dependencies.map(x => x.outboundBus)).pipe(ignoreElements()),\n\n      // Wait for pause() to clear (if necessary).\n      waitable,\n\n      from(handler).pipe(\n        switchMap(handler => new Observable((subscriber: Observer<JobOutboundMessage<O>>) => {\n          if (!handler) {\n            throw new JobDoesNotExistException(name);\n          }\n\n          // Validate the argument.\n          return handler.argumentV.pipe(\n            switchMap(validate => validate(argument)),\n            switchMap(output => {\n              if (!output.success) {\n                throw new JobInboundMessageSchemaValidationError(output.errors);\n              }\n\n              const argument: A = output.data as A;\n              const description = handler.jobDescription;\n              subscriber.next({ kind: JobOutboundMessageKind.OnReady, description });\n\n              const context = {\n                description,\n                dependencies: [...dependencies],\n                inboundBus: inboundBus.asObservable(),\n                scheduler: this as Scheduler<MinimumArgumentT, MinimumInputT, MinimumOutputT>,\n              };\n\n              return handler(argument, context);\n            }),\n          ).subscribe(subscriber);\n        })),\n      ),\n    );\n\n    return this._createJob(name, argument, handler, inboundBus, outboundBus, options);\n  }\n}\n"]}