@angular-devkit/core 12.0.0-rc.0 → 12.0.0

package/src/experimental/jobs/architecture.md

@@ -1,9 +1,10 @@
-
 # Overview
+
 Jobs is a high-order API that adds inputs, runtime type checking, sequencing, and other
 functionality on top of RxJS' `Observable`s.
 
 # Background
+
 An `Observable` (at a higher level) is a function that receives a `Subscriber`, and outputs
 multiple values, and finishes once it calls the `Subscriber.prototype.complete()` method (in
 JavaScript):
@@ -23,17 +24,18 @@ const output1To10EverySecond = function (subscriber) {
 
 const stream$ = new Observable(output1To10EverySecond);
 // Start the function, and output 1 to 100, once per line.
-stream$.subscribe(x => console.log(x));
+stream$.subscribe((x) => console.log(x));
 ```
 
 This, of course, can be typed in TypeScript, but those types are not enforced at runtime.
 
 # Glossary
+
 - `job handler`. The function that implements the job's logic.
 - `raw input`. The input observable sending messages to the job. These messages are of type
-    `JobInboundMessage`.
+  `JobInboundMessage`.
 - `raw output`. The output observer returned from the `job handler`. Messages on this observable
-    are of type `JobOutboundMessage`.
+  are of type `JobOutboundMessage`.
 
 # Description
 
@@ -43,7 +45,7 @@ Json Schema):
 
 ```javascript
 const output1ToXEverySecond = function (x, context) {
-  return new Observable(subscriber => {
+  return new Observable((subscriber) => {
     let t = 0;
 
     // Notify our users that the actual work is started.
@@ -60,7 +62,7 @@ const output1ToXEverySecond = function (x, context) {
     return () => {
       clearInterval(i);
     };
-  })
+  });
 };
 
 // For now, jobs can not be called without a registry and scheduler.
@@ -76,7 +78,7 @@ const scheduler = new SimpleScheduler(registry);
 const job = scheduler.schedule('output-from-1-to-x', 10);
 
 // A Job<> instance has more members, but we only want the output values here.
-job.output.subscribe(x => console.log(x));
+job.output.subscribe((x) => console.log(x));
 ```
 
 This seems like a lot of boilerplate in comparison, but there are a few advantages;
@@ -84,11 +86,12 @@ This seems like a lot of boilerplate in comparison, but there are a few advantag
 1. lifecycle. Jobs can tell when they start doing work and when work is done.
 1. everything is typed, even at runtime.
 1. the context also contains an input Observable that receives typed input messages, including
-    input values, and stop requests.
+   input values, and stop requests.
 1. jobs can also schedule other jobs and wait for them, even if they don't know if a job is
-    implemented in the system.
+   implemented in the system.
 
 ## Diagram
+
 A simpler way to think about jobs in contrast to observables is that job are closer to a Unix
 process. It has an argument (command line flags), receive inputs (STDIN and interrupt signals),
 and output values (STDOUT) as well as diagnostic (STDERR). They can be plugged one into another
@@ -99,7 +102,7 @@ and output values (STDOUT) as well as diagnostic (STDERR). They can be plugged o
 - given I the type of the input
 - given O the type of the output
 
-                              ,______________________   
+                              ,______________________
     JobInboundMessage<I> --> | handler(argument: A) |  --> JobOutboundMessage<O>
                                                             - JobOutboundMessageKind.Output
                                                             - ...
@@ -108,37 +111,38 @@ and output values (STDOUT) as well as diagnostic (STDERR). They can be plugged o
 `JobInboundMessage` includes:
 
 1. `JobInboundMessageKind.Ping`. A simple message that should be answered with
-    `JobOutboundMessageKind.Pong` when the job is responsive. The `id` field of the message should
-    be used when returning `Pong`.
+   `JobOutboundMessageKind.Pong` when the job is responsive. The `id` field of the message should
+   be used when returning `Pong`.
 1. `JobInboundMessageKind.Stop`. The job should be stopped. This is used when
-    cancelling/unsubscribing from the `output` (or by calling `stop()`). Any inputs or outputs
-    after this message will be ignored.
+   cancelling/unsubscribing from the `output` (or by calling `stop()`). Any inputs or outputs
+   after this message will be ignored.
 1. `JobInboundMessageKind.Input` is used when sending inputs to a job. These correspond to the
-    `next` methods of an `Observer` and are reported to the job through its `context.input`
-    Observable. There is no way to communicate an error to the job.
+   `next` methods of an `Observer` and are reported to the job through its `context.input`
+   Observable. There is no way to communicate an error to the job.
 
 `JobOutboundMessage` includes:
 
 1. `JobOutboundMessageKind.Ready`. The `Job<>` was created, its dependencies are done, and the
-    library is validating Argument and calling the internal job code.
+   library is validating Argument and calling the internal job code.
 1. `JobOutboundMessageKind.Start`. The job code itself should send that message when started.
-    `createJobHandler()` will do it automatically.
+   `createJobHandler()` will do it automatically.
 1. `JobOutboundMessageKind.End`. The job has ended. This is done by the job itself and should
-    always be sent when completed. The scheduler will listen to this message to set the state and
-    unblock dependent jobs. `createJobHandler()` automatically send this message.
+   always be sent when completed. The scheduler will listen to this message to set the state and
+   unblock dependent jobs. `createJobHandler()` automatically send this message.
 1. `JobOutboundMessageKind.Pong`. The job should answer a `JobInboundMessageKind.Ping` message with
-    this. Automatically done by `createJobHandler()`.
+   this. Automatically done by `createJobHandler()`.
 1. `JobOutboundMessageKind.Output`. An `Output` has been generated by the job.
 1. `JobOutboundMessageKind.ChannelMessage`, `JobOutboundMessageKind.ChannelError` and
-    `JobOutboundMessageKind.ChannelComplete` are used for output channels. These correspond to
-    the `next`, `error` and `complete` methods of an `Observer` and are available to the callee
-    through the `job.channels` map of Observable.
+   `JobOutboundMessageKind.ChannelComplete` are used for output channels. These correspond to
+   the `next`, `error` and `complete` methods of an `Observer` and are available to the callee
+   through the `job.channels` map of Observable.
 
 Utilities should have some filtering and dispatching to separate observables, as a convenience for
 the user. An example of this would be the `Job.prototype.output` observable which only contains
 the value contained by messages of type `JobOutboundMessageKind.Output`.
 
 # Higher Order Jobs
+
 Because jobs are expected to be pure functions, they can be composed or transformed to create
 more complex behaviour, similar to how RxJS operators can transform observables.
 
@@ -146,31 +150,31 @@ more complex behaviour, similar to how RxJS operators can transform observables.
 // Runs a job on the hour, every hour, regardless of how long the job takes.
 // This creates a job function that can be registered by itself.
 function scheduleJobOnTheHour(jobFunction) {
-  return function(argument, context) {
-    return new Observable(observer => {
+  return function (argument, context) {
+    return new Observable((observer) => {
       let timeout = 0;
-   
+
       function _timeoutToNextHour() {
         // Just wait until the next hour.
         const t = new Date();
         const secondsToNextHour = 3600 - t.getSeconds() - t.getMinutes() * 60;
         timeout = setTimeout(_scheduleJobAndWaitAnHour, secondsToNextHour);
       }
-   
+
       function _scheduleJobAndWaitAnHour() {
         jobFunction(argument, context).subscribe(
-          message => observer.next(message),
-          error => observer.error(error),
+          (message) => observer.next(message),
+          (error) => observer.error(error),
           // Do not forward completion, but use it to schedule the next job run.
           () => {
             _timeoutToNextHour();
           },
         );
       }
-   
+
       // Kick off by waiting for next hour.
       _timeoutToNextHour();
-   
+
       return () => clearTimeout(timeout);
     });
   };
@@ -184,9 +188,9 @@ Another way to compose jobs is to schedule jobs based on their name, from other
 // This creates a high order job by getting a job name and an argument, and scheduling the job
 // every hour.
 function scheduleJobOnTheHour(job, context) {
-  const { name, argument } = job;  // Destructure our input.
+  const { name, argument } = job; // Destructure our input.
 
-  return new Observable(observer => {
+  return new Observable((observer) => {
     let timeout = 0;
 
     function _timeoutToNextHour() {
@@ -200,8 +204,8 @@ function scheduleJobOnTheHour(job, context) {
       const subJob = context.scheduler.schedule(name, argument);
       // We do not forward the input to the sub-job but that would be a valid example as well.
       subJob.outboundBus.subscribe(
-        message => observer.next(message),
-        error => observer.error(error),
+        (message) => observer.next(message),
+        (error) => observer.error(error),
         // Do not forward completion, but use it to schedule the next job run.
         () => {
           _timeoutToNextHour();
@@ -239,15 +243,16 @@ const job = scheduler.schedule('schedule-job-on-the-hour', {
     to: '/volumes/usb-key',
   },
 });
-job.output.subscribe(x => console.log(x));
+job.output.subscribe((x) => console.log(x));
 ```
 
 # Limitations
+
 Jobs input, output and argument must be serializable to JSONs. This is a big limitation in usage,
 but comes with the benefit that jobs can be serialized and called across memory boundaries. An
 example would be an operator that takes a module path and run the job from that path in a separate
 process. Or even a separate server, using HTTP calls.
- 
+
 Another limitation is that the boilerplate is complex. Manually managing start/end life cycle, and
 other messages such as ping/pong, etc. is tedious and requires a lot of code. A good way to keep
 this limitation under control is to provide helpers to create `JobHandler`s which manage those

package/src/experimental/jobs/create-job-handler.d.ts

@@ -1,10 +1,9 @@
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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
- *
  */
 import { Observable, Observer } from 'rxjs';
 import { BaseException } from '../../exception/index';

package/src/experimental/jobs/create-job-handler.js

@@ -1,14 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLoggerJob = exports.createJobFactory = exports.createJobHandler = exports.ChannelAlreadyExistException = void 0;
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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.createLoggerJob = exports.createJobFactory = exports.createJobHandler = exports.ChannelAlreadyExistException = void 0;
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const index_1 = require("../../exception/index");
@@ -33,7 +32,7 @@ function createJobHandler(fn, options = {}) {
         const inboundBus = context.inboundBus;
         const inputChannel = new rxjs_1.Subject();
         let subscription;
-        return new rxjs_1.Observable(subject => {
+        return new rxjs_1.Observable((subject) => {
             function complete() {
                 if (subscription) {
                     subscription.unsubscribe();
@@ -43,7 +42,7 @@ function createJobHandler(fn, options = {}) {
                 inputChannel.complete();
             }
             // Handle input.
-            const inboundSub = inboundBus.subscribe(message => {
+            const inboundSub = inboundBus.subscribe((message) => {
                 switch (message.kind) {
                     case api_1.JobInboundMessageKind.Ping:
                         subject.next({ kind: api_1.JobOutboundMessageKind.Pong, description, id: message.id });
@@ -68,11 +67,14 @@ function createJobHandler(fn, options = {}) {
                         throw new ChannelAlreadyExistException(name);
                     }
                     const channelSubject = new rxjs_1.Subject();
-                    const channelSub = channelSubject.subscribe(message => {
+                    const channelSub = channelSubject.subscribe((message) => {
                         subject.next({
-                            kind: api_1.JobOutboundMessageKind.ChannelMessage, description, name, message,
+                            kind: api_1.JobOutboundMessageKind.ChannelMessage,
+                            description,
+                            name,
+                            message,
                         });
-                    }, error => {
+                    }, (error) => {
                         subject.next({ kind: api_1.JobOutboundMessageKind.ChannelError, description, name, error });
                         // This can be reopened.
                         channels.delete(name);
@@ -97,7 +99,7 @@ function createJobHandler(fn, options = {}) {
             else if (!rxjs_1.isObservable(result)) {
                 result = rxjs_1.of(result);
             }
-            subscription = result.subscribe((value) => subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value }), error => subject.error(error), () => complete());
+            subscription = result.subscribe((value) => subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value }), (error) => subject.error(error), () => complete());
             subscription.add(inboundSub);
             return subscription;
         });
@@ -112,8 +114,7 @@ exports.createJobHandler = createJobHandler;
  */
 function createJobFactory(loader, options = {}) {
     const handler = (argument, context) => {
-        return rxjs_1.from(loader())
-            .pipe(operators_1.switchMap(fn => fn(argument, context)));
+        return rxjs_1.from(loader()).pipe(operators_1.switchMap((fn) => fn(argument, context)));
     };
     return Object.assign(handler, { jobDescription: options });
 }
@@ -124,8 +125,10 @@ exports.createJobFactory = createJobFactory;
  */
 function createLoggerJob(job, logger) {
     const handler = (argument, context) => {
-        context.inboundBus.pipe(operators_1.tap(message => logger.info(`Input: ${JSON.stringify(message)}`))).subscribe();
-        return job(argument, context).pipe(operators_1.tap(message => logger.info(`Message: ${JSON.stringify(message)}`), error => logger.warn(`Error: ${JSON.stringify(error)}`), () => logger.info(`Completed`)));
+        context.inboundBus
+            .pipe(operators_1.tap((message) => logger.info(`Input: ${JSON.stringify(message)}`)))
+            .subscribe();
+        return job(argument, context).pipe(operators_1.tap((message) => logger.info(`Message: ${JSON.stringify(message)}`), (error) => logger.warn(`Error: ${JSON.stringify(error)}`), () => logger.info(`Completed`)));
     };
     return Object.assign(handler, job);
 }

package/src/experimental/jobs/dispatcher.d.ts

@@ -1,10 +1,9 @@
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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
- *
  */
 import { JsonValue } from '../../json/index';
 import { Readwrite } from '../../utils/index';

package/src/experimental/jobs/dispatcher.js

@@ -1,4 +1,11 @@
 "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.createDispatcher = void 0;
 const api_1 = require("./api");

package/src/experimental/jobs/exception.d.ts

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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

package/src/experimental/jobs/exception.js

@@ -1,13 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobDoesNotExistException = exports.JobNameAlreadyRegisteredException = void 0;
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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.JobDoesNotExistException = exports.JobNameAlreadyRegisteredException = void 0;
 const index_1 = require("../../exception/index");
 class JobNameAlreadyRegisteredException extends index_1.BaseException {
     constructor(name) {

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

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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

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

@@ -1,13 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FallbackRegistry = void 0;
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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.FallbackRegistry = void 0;
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 /**
@@ -21,7 +21,7 @@ class FallbackRegistry {
         this._fallbacks.push(registry);
     }
     get(name) {
-        return rxjs_1.from(this._fallbacks).pipe(operators_1.concatMap(fb => fb.get(name)), operators_1.first(x => x !== null, null));
+        return rxjs_1.from(this._fallbacks).pipe(operators_1.concatMap((fb) => fb.get(name)), operators_1.first((x) => x !== null, null));
     }
 }
 exports.FallbackRegistry = FallbackRegistry;

package/src/experimental/jobs/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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

package/src/experimental/jobs/index.js

@@ -1,4 +1,11 @@
 "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
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -10,13 +17,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 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
- */
 __exportStar(require("./api"), exports);
 __exportStar(require("./create-job-handler"), exports);
 __exportStar(require("./exception"), exports);

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

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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

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

@@ -1,13 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleJobRegistry = void 0;
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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.SimpleJobRegistry = void 0;
 const rxjs_1 = require("rxjs");
 const json_1 = require("../../json");
 const api_1 = require("./api");
@@ -62,7 +62,9 @@ class SimpleJobRegistry {
             output,
             input,
         };
-        const jobHandler = Object.assign(handler.bind(undefined), { jobDescription });
+        const jobHandler = Object.assign(handler.bind(undefined), {
+            jobDescription,
+        });
         this._jobNames.set(name, jobHandler);
     }
     /**

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

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright Google Inc. All Rights Reserved.
+ * 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