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

package/README.md

@@ -1,25 +1,28 @@
 # Schematics
+
 > A scaffolding library for the modern web.
 
 ## Description
+
 Schematics are generators that transform an existing filesystem. They can create files, refactor existing files, or move files around.
 
 What distinguishes Schematics from other generators, such as Yeoman or Yarn Create, is that schematics are purely descriptive; no changes are applied to the actual filesystem until everything is ready to be committed. There is no side effect, by design, in Schematics.
 
 # Glossary
 
-| Term | Description |
-|------|-------------|
-| **Schematics** | A generator that executes descriptive code without side effects on an existing file system. |
-| **Collection** | A list of schematics metadata. Schematics can be referred by name inside a collection. |
-| **Tool**       | The code using the Schematics library. |
-| **Tree**       | A staging area for changes, containing the original file system, and a list of changes to apply to it. |
-| **Rule**       | A function that applies actions to a `Tree`. It returns a new `Tree` that will contain all transformations to be applied. |
-| **Source**     | A function that creates an entirely new `Tree` from an empty filesystem. For example, a file source could read files from disk and create a Create Action for each of those.
-| **Action**     | An atomic operation to be validated and committed to a filesystem or a `Tree`. Actions are created by schematics. |
-| **Sink**       | The final destination of all `Action`s. |
+| Term           | Description                                                                                                                                                                  |
+| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Schematics** | A generator that executes descriptive code without side effects on an existing file system.                                                                                  |
+| **Collection** | A list of schematics metadata. Schematics can be referred by name inside a collection.                                                                                       |
+| **Tool**       | The code using the Schematics library.                                                                                                                                       |
+| **Tree**       | A staging area for changes, containing the original file system, and a list of changes to apply to it.                                                                       |
+| **Rule**       | A function that applies actions to a `Tree`. It returns a new `Tree` that will contain all transformations to be applied.                                                    |
+| **Source**     | A function that creates an entirely new `Tree` from an empty filesystem. For example, a file source could read files from disk and create a Create Action for each of those. |
+| **Action**     | An atomic operation to be validated and committed to a filesystem or a `Tree`. Actions are created by schematics.                                                            |
+| **Sink**       | The final destination of all `Action`s.                                                                                                                                      |
 
 # Tooling
+
 Schematics is a library, and does not work by itself. A [reference CLI](https://github.com/angular/angular-cli/blob/master/packages/angular_devkit/schematics_cli/bin/schematics.ts) is available on this repository, and is published on NPM at [@angular-devkit/schematics-cli](https://www.npmjs.com/package/@angular-devkit/schematics-cli). This document explains the library usage and the tooling API, but does not go into the tool implementation itself.
 
 The tooling is responsible for the following tasks:
@@ -27,7 +30,7 @@ The tooling is responsible for the following tasks:
 1. Create the Schematic Engine, and pass in a Collection and Schematic loader.
 1. Understand and respect the Schematics metadata and dependencies between collections. Schematics can refer to dependencies, and it's the responsibility of the tool to honor those dependencies. The reference CLI uses NPM packages for its collections.
 1. Create the Options object. Options can be anything, but the schematics can specify a JSON Schema that should be respected. The reference CLI, for example, parses the arguments as a JSON object and validates it with the Schema specified by the collection.
-  1. Schematics provides some JSON Schema formats for validation that tooling should add. These validate paths, html selectors and app names. Please check the reference CLI for how these can be added.
+1. Schematics provides some JSON Schema formats for validation that tooling should add. These validate paths, html selectors and app names. Please check the reference CLI for how these can be added.
 1. Call the schematics with the original Tree. The tree should represent the initial state of the filesystem. The reference CLI uses the current directory for this.
 1. Create a Sink and commit the result of the schematics to the Sink. Many sinks are provided by the library; FileSystemSink and DryRunSink are examples.
 1. Output any logs propagated by the library, including debugging information.
@@ -35,25 +38,30 @@ The tooling is responsible for the following tasks:
 The tooling API is composed of the following pieces:
 
 ## Engine
+
 The `SchematicEngine` is responsible for loading and constructing `Collection`s and `Schematics`. When creating an engine, the tooling provides an `EngineHost` interface that understands how to create a `CollectionDescription` from a name, and how to create a `SchematicDescription`.
 
 # Schematics (Generators)
+
 Schematics are generators and part of a `Collection`.
 
 ## Collection
+
 A Collection is defined by a `collection.json` file (in the reference CLI). This JSON defines the following properties:
 
-| Prop Name | Type | Description |
-|---|---|---|
-| **name** | `string` | The name of the collection. |
-| **version** | `string` | Unused field. |
+| Prop Name   | Type     | Description                 |
+| ----------- | -------- | --------------------------- |
+| **name**    | `string` | The name of the collection. |
+| **version** | `string` | Unused field.               |
 
 ## Schematic
 
 # Operators, Sources and Rules
+
 A `Source` is a generator of a `Tree`; it creates an entirely new root tree from nothing. A `Rule` is a transformation from one `Tree` to another. A `Schematic` (at the root) is a `Rule` that is normally applied on the filesystem.
 
 ## Operators
+
 `FileOperator`s apply changes to a single `FileEntry` and return a new `FileEntry`. The result follows these rules:
 
 1. If the `FileEntry` returned is null, a `DeleteAction` will be added to the action list.
@@ -63,66 +71,71 @@ A `Source` is a generator of a `Tree`; it creates an entirely new root tree from
 It is impossible to create files using a `FileOperator`.
 
 ## Provided Operators
+
 The Schematics library provides multiple `Operator` factories by default that cover basic use cases:
 
-| FileOperator | Description |
-|---|---|
+| FileOperator                     | Description                                         |
+| -------------------------------- | --------------------------------------------------- |
 | `contentTemplate<T>(options: T)` | Apply a content template (see the Template section) |
-| `pathTemplate<T>(options: T)` | Apply a path template (see the Template section) |
+| `pathTemplate<T>(options: T)`    | Apply a path template (see the Template section)    |
 
 ## Provided Sources
+
 The Schematics library additionally provides multiple `Source` factories by default:
 
-| Source | Description |
-|---|---|
-| `empty()` | Creates a source that returns an empty `Tree`. |
-| `source(tree: Tree)` | Creates a `Source` that returns the `Tree` passed in as argument. |
-| `url(url: string)` | Loads a list of files from the given URL and returns a `Tree` with the files as `CreateAction` applied to an empty `Tree`. |
-| `apply(source: Source, rules: Rule[])` | Apply a list of `Rule`s to a source, and return the resulting `Source`. |
+| Source                                 | Description                                                                                                                |
+| -------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `empty()`                              | Creates a source that returns an empty `Tree`.                                                                             |
+| `source(tree: Tree)`                   | Creates a `Source` that returns the `Tree` passed in as argument.                                                          |
+| `url(url: string)`                     | Loads a list of files from the given URL and returns a `Tree` with the files as `CreateAction` applied to an empty `Tree`. |
+| `apply(source: Source, rules: Rule[])` | Apply a list of `Rule`s to a source, and return the resulting `Source`.                                                    |
 
 ## Provided Rules
-The schematics library also provides `Rule` factories by default:
 
-| Rule | Description |
-|---|---|
-| `noop()` | Returns the input `Tree` as is. |
-| `chain(rules: Rule[])` | Returns a `Rule` that's the concatenation of other `Rule`s. |
-| `forEach(op: FileOperator)` | Returns a `Rule` that applies an operator to every file of the input `Tree`. |
-| `move(root: string)` | Moves all the files from the input to a subdirectory. |
-| `merge(other: Tree)` | Merge the input `Tree` with the other `Tree`. |
-| `contentTemplate<T>(options: T)` | Apply a content template (see the Template section) to the entire `Tree`. |
-| `pathTemplate<T>(options: T)` | Apply a path template (see the Template section) to the entire `Tree`. |
-| `template<T>(options: T)` | Apply both path and content templates (see the Template section) to the entire `Tree`. |
-| `filter(predicate: FilePredicate<boolean>)` | Returns the input `Tree` with files that do not pass the `FilePredicate`. |
+The schematics library also provides `Rule` factories by default:
 
+| Rule                                        | Description                                                                            |
+| ------------------------------------------- | -------------------------------------------------------------------------------------- |
+| `noop()`                                    | Returns the input `Tree` as is.                                                        |
+| `chain(rules: Rule[])`                      | Returns a `Rule` that's the concatenation of other `Rule`s.                            |
+| `forEach(op: FileOperator)`                 | Returns a `Rule` that applies an operator to every file of the input `Tree`.           |
+| `move(root: string)`                        | Moves all the files from the input to a subdirectory.                                  |
+| `merge(other: Tree)`                        | Merge the input `Tree` with the other `Tree`.                                          |
+| `contentTemplate<T>(options: T)`            | Apply a content template (see the Template section) to the entire `Tree`.              |
+| `pathTemplate<T>(options: T)`               | Apply a path template (see the Template section) to the entire `Tree`.                 |
+| `template<T>(options: T)`                   | Apply both path and content templates (see the Template section) to the entire `Tree`. |
+| `filter(predicate: FilePredicate<boolean>)` | Returns the input `Tree` with files that do not pass the `FilePredicate`.              |
 
 # Templating
+
 As referenced above, some functions are based upon a file templating system, which consists of path and content templating.
 
 The system operates on placeholders defined inside files or their paths as loaded in the `Tree` and fills these in as defined in the following, using values passed into the `Rule` which applies the templating (i.e. `template<T>(options: T)`).
 
 ## Path Templating
-| Placeholder | Description |
-|---|---|
-| __variable__ | Replaced with the value of `variable`. |
-| __variable@function__ | Replaced with the result of the call `function(variable)`. Can be chained to the left (`__variable@function1@function2__ ` etc).  |
+
+| Placeholder           | Description                                                                                                                      |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| **variable**          | Replaced with the value of `variable`.                                                                                           |
+| **variable@function** | Replaced with the result of the call `function(variable)`. Can be chained to the left (`__variable@function1@function2__ ` etc). |
 
 ## Content Templating
-| Placeholder | Description |
-|---|---|
-| <%= expression %> | Replaced with the result of the call of the given expression. This only supports direct expressions, no structural (for/if/...) JavaScript. |
-| <%- expression %> | Same as above, but the value of the result will be escaped for HTML when inserted (i.e. replacing '<' with '&lt;') |
-| <% inline code %> | Inserts the given code into the template structure, allowing to insert structural JavaScript. |
-| <%# text %> | A comment, which gets entirely dropped. |
 
+| Placeholder       | Description                                                                                                                                 |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| <%= expression %> | Replaced with the result of the call of the given expression. This only supports direct expressions, no structural (for/if/...) JavaScript. |
+| <%- expression %> | Same as above, but the value of the result will be escaped for HTML when inserted (i.e. replacing '<' with '&lt;')                          |
+| <% inline code %> | Inserts the given code into the template structure, allowing to insert structural JavaScript.                                               |
+| <%# text %>       | A comment, which gets entirely dropped.                                                                                                     |
 
 # Examples
 
 ## Simple
+
 An example of a simple Schematics which creates a "hello world" file, using an option to determine its path:
 
 ```typescript
-import {Tree} from '@angular-devkit/schematics';
+import { Tree } from '@angular-devkit/schematics';
 
 export default function MySchematic(options: any) {
   return (tree: Tree) => {
@@ -138,6 +151,7 @@ A few things from this example:
 1. It returns a [`Rule`](src/engine/interface.ts#L73), which is a transformation from a `Tree` to another `Tree`.
 
 ## Templating
+
 A simplified example of a Schematics which creates a file containing a new Class, using an option to determine its name:
 
 ```typescript
@@ -152,8 +166,15 @@ export class <%= classify(name) %> {
 
 import { strings } from '@angular-devkit/core';
 import {
-  Rule, SchematicContext, SchematicsException, Tree,
-  apply, branchAndMerge, mergeWith, template, url,
+  Rule,
+  SchematicContext,
+  SchematicsException,
+  Tree,
+  apply,
+  branchAndMerge,
+  mergeWith,
+  template,
+  url,
 } from '@angular-devkit/schematics';
 import { Schema as ClassOptions } from './schema';
 
@@ -163,15 +184,12 @@ export default function (options: ClassOptions): Rule {
       throw new SchematicsException('Option (name) is required.');
     }
 
-    const templateSource = apply(
-      url('./files'),
-      [
-        template({
-          ...strings,
-          ...options,
-        }),
-      ]
-    );
+    const templateSource = apply(url('./files'), [
+      template({
+        ...strings,
+        ...options,
+      }),
+    ]);
 
     return branchAndMerge(mergeWith(templateSource));
   };
@@ -179,14 +197,16 @@ export default function (options: ClassOptions): Rule {
 ```
 
 Additional things from this example:
+
 1. `strings` provides the used `dasherize` and `classify` functions, among others.
 1. The files are on-disk in the same root directory as the `index.ts` and loaded into a `Tree`.
 1. Then the `template` `Rule` fills in the specified templating placeholders. For this, it only knows about the variables and functions passed to it via the options-object.
 1. Finally, the resulting `Tree`, containing the new file, is merged with the existing files of the project which the Schematic is run on.
 
 # Future Work
+
 Schematics is not done yet. Here's a list of things we are considering:
 
-* Smart defaults for Options. Having a JavaScript function for default values based on other default values.
-* Prompt for input options. This should only be prompted for the original schematics, dependencies to other schematics should not trigger another prompting.
-* Tasks for running tooling-specific jobs before and after a schematics has been scaffolded. Such tasks can involve initialize git, or npm install. A specific list of tasks should be provided by the tool, with unsupported tasks generating an error.
+- Smart defaults for Options. Having a JavaScript function for default values based on other default values.
+- Prompt for input options. This should only be prompted for the original schematics, dependencies to other schematics should not trigger another prompting.
+- Tasks for running tooling-specific jobs before and after a schematics has been scaffolded. Such tasks can involve initialize git, or npm install. A specific list of tasks should be provided by the tool, with unsupported tasks generating an error.

package/collection-schema.json

@@ -59,17 +59,12 @@
             "description": "Whether or not this schematic can be called from an external schematic, or a tool. This implies hidden: true."
           }
         },
-        "required": [
-          "factory",
-          "description"
-        ]
+        "required": ["factory", "description"]
       }
     },
     "version": {
       "type": "string"
     }
   },
-  "required": [
-    "schematics"
-  ]
+  "required": ["schematics"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-devkit/schematics",
-  "version": "12.0.0-rc.0",
+  "version": "12.0.0",
   "description": "Angular Schematics - Library",
   "main": "src/index.js",
   "typings": "src/index.d.ts",
@@ -18,7 +18,7 @@
     "schematics"
   ],
   "dependencies": {
-    "@angular-devkit/core": "12.0.0-rc.0",
+    "@angular-devkit/core": "12.0.0",
     "ora": "5.4.0",
     "rxjs": "6.6.7"
   },
@@ -27,7 +27,7 @@
     "url": "https://github.com/angular/angular-cli.git"
   },
   "engines": {
-    "node": ">= 12.13.0",
+    "node": "^12.14.1 || ^14.0.0",
     "npm": "^6.11.0 || ^7.5.6",
     "yarn": ">= 1.13.0"
   },

package/src/_golden-api.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/_golden-api.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * @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/engine/engine.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="node" />
 /**
  * @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
  */
+/// <reference types="node" />
 import { BaseException } from '@angular-devkit/core';
 import { Observable } from 'rxjs';
 import { Url } from 'url';

package/src/engine/engine.js

@@ -1,13 +1,13 @@
 "use strict";
-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;
 /**
  * @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.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");
@@ -16,11 +16,15 @@ 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}".`); }
+    constructor(url) {
+        super(`Unknown Protocol on url "${url}".`);
+    }
 }
 exports.UnknownUrlSourceProtocol = UnknownUrlSourceProtocol;
 class UnknownCollectionException extends core_1.BaseException {
-    constructor(name) { super(`Unknown collection "${name}".`); }
+    constructor(name) {
+        super(`Unknown collection "${name}".`);
+    }
 }
 exports.UnknownCollectionException = UnknownCollectionException;
 class CircularCollectionException extends core_1.BaseException {
@@ -42,7 +46,9 @@ class PrivateSchematicException extends core_1.BaseException {
 }
 exports.PrivateSchematicException = PrivateSchematicException;
 class SchematicEngineConflictingException extends core_1.BaseException {
-    constructor() { super(`A schematic was called from a different engine as its parent.`); }
+    constructor() {
+        super(`A schematic was called from a different engine as its parent.`);
+    }
 }
 exports.SchematicEngineConflictingException = SchematicEngineConflictingException;
 class UnregisteredTaskException extends core_1.BaseException {
@@ -64,8 +70,12 @@ class CollectionImpl {
         this._engine = _engine;
         this.baseDescriptions = baseDescriptions;
     }
-    get description() { return this._description; }
-    get name() { return this.description.name || '<unknown>'; }
+    get description() {
+        return this._description;
+    }
+    get name() {
+        return this.description.name || '<unknown>';
+    }
     createSchematic(name, allowPrivate = false) {
         return this._engine.createSchematic(name, this, allowPrivate);
     }
@@ -91,7 +101,7 @@ class TaskScheduler {
         if (!dependencies) {
             return new Set();
         }
-        const tasks = dependencies.map(dep => {
+        const tasks = dependencies.map((dep) => {
             const task = this._taskIds.get(dep);
             if (!task) {
                 throw new UnknownTaskDependencyException(dep);
@@ -131,8 +141,12 @@ class SchematicEngine {
         this._schematicCache = new WeakMap();
         this._taskSchedulers = new Array();
     }
-    get workflow() { return this._workflow || null; }
-    get defaultMergeStrategy() { return this._host.defaultMergeStrategy || interface_1.MergeStrategy.Default; }
+    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) {
@@ -175,13 +189,12 @@ class SchematicEngine {
             interactive = parent.interactive;
         }
         let context = {
-            debug: parent && parent.debug || false,
+            debug: (parent && parent.debug) || false,
             engine: this,
-            logger: (parent && parent.logger && parent.logger.createChild(schematic.description.name))
-                || new core_1.logging.NullLogger(),
+            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,
+            strategy: parent && parent.strategy !== undefined ? parent.strategy : this.defaultMergeStrategy,
             interactive,
             addTask,
         };
@@ -251,8 +264,10 @@ class SchematicEngine {
     }
     createSourceFromUrl(url, context) {
         switch (url.protocol) {
-            case 'null:': return () => new null_1.NullTree();
-            case 'empty:': return () => static_1.empty();
+            case 'null:':
+                return () => new null_1.NullTree();
+            case 'empty:':
+                return () => static_1.empty();
             default:
                 const hostSource = this._host.createSourceFromUrl(url, context);
                 if (!hostSource) {
@@ -263,15 +278,13 @@ class SchematicEngine {
     }
     executePostTasks() {
         const executors = new Map();
-        const taskObservable = rxjs_1.from(this._taskSchedulers)
-            .pipe(operators_1.concatMap(scheduler => scheduler.finalize()), operators_1.concatMap(task => {
+        const taskObservable = rxjs_1.from(this._taskSchedulers).pipe(operators_1.concatMap((scheduler) => scheduler.finalize()), 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(operators_1.concatMap(executor => {
+            return this._host.createTaskExecutor(name).pipe(operators_1.concatMap((executor) => {
                 executors.set(name, executor);
                 return executor(options, task.context);
             }));

package/src/engine/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/engine/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("./engine"), exports);
 __exportStar(require("./interface"), exports);
 __exportStar(require("./schematic"), exports);

package/src/engine/interface.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="node" />
 /**
  * @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
  */
+/// <reference types="node" />
 import { analytics, logging } from '@angular-devkit/core';
 import { Observable } from 'rxjs';
 import { Url } from 'url';

package/src/engine/interface.js

@@ -1,2 +1,9 @@
 "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 });

package/src/engine/schematic.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/engine/schematic.js

@@ -1,13 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchematicImpl = exports.InvalidSchematicsNameException = 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.SchematicImpl = exports.InvalidSchematicsNameException = void 0;
 const core_1 = require("@angular-devkit/core");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
@@ -29,12 +29,17 @@ class SchematicImpl {
             throw new InvalidSchematicsNameException(_description.name);
         }
     }
-    get description() { return this._description; }
-    get collection() { return this._collection; }
+    get description() {
+        return this._description;
+    }
+    get collection() {
+        return this._collection;
+    }
     call(options, host, parentContext, executionOptions) {
         const context = this._engine.createContext(this, parentContext, executionOptions);
-        return host
-            .pipe(operators_1.first(), operators_1.concatMap(tree => this._engine.transformOptions(this, options, context).pipe(operators_1.map(o => [tree, o]))), operators_1.concatMap(([tree, transformedOptions]) => {
+        return host.pipe(operators_1.first(), operators_1.concatMap((tree) => this._engine
+            .transformOptions(this, options, context)
+            .pipe(operators_1.map((o) => [tree, o]))), operators_1.concatMap(([tree, transformedOptions]) => {
             let input;
             let scoped = false;
             if (executionOptions && executionOptions.scope) {
@@ -44,7 +49,7 @@ class SchematicImpl {
             else {
                 input = tree;
             }
-            return call_1.callRule(this._factory(transformedOptions), rxjs_1.of(input), context).pipe(operators_1.map(output => {
+            return call_1.callRule(this._factory(transformedOptions), rxjs_1.of(input), context).pipe(operators_1.map((output) => {
                 if (output === input) {
                     return tree;
                 }

package/src/exception/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