Angular13 Angular 库的原理图

库的原理图

当创建 Angular 库时，你可以为同时为它打包进一组原理图，并把它与 Angular CLI 集成在一起。借助原理图，用户可以用 ​ng add​ 来安装你这个库的初始版本，可以用 ​ng generate​ 来创建你在库中定义的一些工件，可以用 ​ng update​ 来调整他们的项目，以支持你在库的新版本中引入的重大变更。

这三种原理图都可以作为你打包进库中的集合的一部分。

下载库的原理图项目以获取一个已完成下列步骤的例子。

创建一个原理图集合

要开始一个集合，你需要创建一些原理图文件。下列步骤说明了如何在不修改任何项目文件的情况下添加初始支持。

1. 在库的根文件夹中，创建一个 ​schematics/​ 文件夹。
2. 在 ​schematics/​ 文件夹中，为你的第一个原理图创建一个 ​ng-add/​ 文件夹。
3. 在 ​schematics/​ 文件夹的根级，创建一个 ​collection.json​ 文件。
4. 编辑 ​collection.json​ 文件来定义你的集合的初始模式定义。

{
  "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
  "schematics": {
    "ng-add": {
      "description": "Add my library to the project.",
      "factory": "./ng-add/index#ngAdd"
    }
  }
}

• ​$schema​ 路径是相对于 Angular Devkit 集合模式定义的。
• ​schematics ​对象描述了该集合中的命名原理图。
• 第一个条目是名为 ​ng-add​ 的原理图。它包含了描述，并指向执行此原理图时要调用的工厂函数。

{
  "name": "my-lib",
  "version": "0.0.1",
  "schematics": "./schematics/collection.json",
}

你所创建的初始模式告诉 CLI 在哪里可以找到支持 ​ng add​ 命令的原理图。现在，你已准备好创建该原理图了。

提供安装支持

​ng add​ 命令的原理图可以增强用户的初始安装过程。可以按如下步骤定义这种原理图。

1. 进入 ​<lib-root>/schematics/ng-add/​ 目录。
2. 创建主文件 ​index.ts​。
3. 打开 ​index.ts​ 并添加原理图工厂函数的源代码。

import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
// Just return the tree
export function ngAdd(): Rule {
  return (tree: Tree, context: SchematicContext) => {
    context.addTask(new NodePackageInstallTask());
    return tree;
  };
}

提供初始 ​ng add​ 支持所需的唯一步骤是使用 ​SchematicContext ​来触发安装任务。该任务会借助用户首选的包管理器将该库添加到宿主项目的 ​package.json​ 配置文件中，并将其安装到该项目的 ​node_modules ​目录下。

在这个例子中，该函数会接收当前的 ​Tree ​并返回它而不作任何修改。如果需要，也可以在安装软件包时进行额外的设置，比如生成文件、更新配置、或者库所需的任何其它初始设置。

定义依赖类型

如果该库应该添加到 ​dependencies ​中、​devDepedencies ​中，或者不用保存到项目的 ​package.json​ 配置文件中，请使用 ​ng-add​ 的 ​save ​选项进行配置

"ng-add": {
  "save": "devDependencies"
},

可能的值有：

构建你的原理图

要把你的原理图和库打包到一起，就必须把这个库配置成单独构建原理图，然后再把它们添加到发布包中。你必须先构建库再构建原理图，这样才能把它们放到正确的目录下。

• 你的库需要一个自定义的 Typescript 配置文件，里面带有如何把原理图编译进库的发布版的一些指令。
• 要把这些原理图添加到库的发布包中，就要把这些脚本添加到该库的 ​package.json​ 文件中。

假设你在 Angular 工作区中有一个库项目 ​my-lib​。要想告诉库如何构建原理图，就要在生成的 ​tsconfig.lib.json​ 库配置文件旁添加一个 ​tsconfig.schematics.json​ 文件。

1. 编辑 ​tsconfig.schematics.json​ 文件，添加如下内容。

{
  "compilerOptions": {
    "baseUrl": ".",
    "lib": [
      "es2018",
      "dom"
    ],
    "declaration": true,
    "module": "commonjs",
    "moduleResolution": "node",
    "noEmitOnError": true,
    "noFallthroughCasesInSwitch": true,
    "noImplicitAny": true,
    "noImplicitThis": true,
    "noUnusedParameters": true,
    "noUnusedLocals": true,
    "rootDir": "schematics",
    "outDir": "../../dist/my-lib/schematics",
    "skipDefaultLibCheck": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "strictNullChecks": true,
    "target": "es6",
    "types": [
      "jasmine",
      "node"
    ]
  },
  "include": [
    "schematics/**/*"
  ],
  "exclude": [
    "schematics/*/files/**/*"
  ]
}

{
  "name": "my-lib",
  "version": "0.0.1",
  "scripts": {
    "build": "tsc -p tsconfig.schematics.json",
    "postbuild": "copyfiles schematics/*/schema.json schematics/*/files/** schematics/collection.json ../../dist/my-lib/"
  },
  "peerDependencies": {
    "@angular/common": "^7.2.0",
    "@angular/core": "^7.2.0"
  },
  "schematics": "./schematics/collection.json",
  "ng-add": {
    "save": "devDependencies"
  },
  "devDependencies": {
    "copyfiles": "file:../../node_modules/copyfiles",
    "typescript": "file:../../node_modules/typescript"
  }
}

• ​build ​脚本使用自定义的 ​tsconfig.schematics.json​ 文件来编译你的原理图。
• ​postbuild ​脚本会在 ​build ​脚本完成后复制原理图文件。
• ​build ​和 ​postbuild ​脚本都需要用到 ​copyfiles ​和 ​typescript ​依赖项。要安装这些依赖项，请导航到 ​devDependencies ​中定义的路径，并在运行这些脚本之前运行 ​npm install​ 命令。

提供生成器支持

你可以把一个命名原理图添加到集合中，让你的用户可以使用 ​ng generate​ 命令来创建你在库中定义的工件。

我们假设你的库定义了一项需要进行某些设置的服务 ​my-service​。你希望用户能够用下面的 CLI 命令来生成它。

ng generate my-lib:my-service

首先，在 ​schematics ​文件夹中新建一个子文件夹 ​my-service​。

配置新的原理图

当你要把一个原理图添加到集合中时，就必须在该集合的模式中指向它，并提供一些配置文件来定义用户可以传给该命令的选项。

1. 编辑一下 ​schematics/collection.json​ 文件，指向新的原理图子文件夹，并附上一个指向模式文件的指针，该文件将会指定新原理图的输入。

{
  "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
  "schematics": {
    "ng-add": {
      "description": "Add my library to the project.",
      "factory": "./ng-add/index#ngAdd"
    },
    "my-service": {
      "description": "Generate a service in the project.",
      "factory": "./my-service/index#myService",
      "schema": "./my-service/schema.json"
    }
  }
}

{
  "$schema": "http://json-schema.org/schema",
  "$id": "SchematicsMyService",
  "title": "My Service Schema",
  "type": "object",
  "properties": {
    "name": {
      "description": "The name of the service.",
      "type": "string"
    },
    "path": {
      "type": "string",
      "format": "path",
      "description": "The path to create the service.",
      "visible": false
    },
    "project": {
      "type": "string",
      "description": "The name of the project.",
      "$default": {
        "$source": "projectName"
      }
    }
   },
  "required": [
    "name"
  ]
}

• id：这个模式定义在集合中的唯一 ID。
• title：一个人类可读的模式描述。
• type：由这些属性提供的类型描述符。
• properties：一个定义该原理图可用选项的对象。

每个选项都会把 key 与类型、描述和一个可选的别名关联起来。该类型定义了你所期望的值的形态，并在用户请求你的原理图给出用法帮助时显示这份描述。

export interface Schema {
  // The name of the service.
  name: string;
  // The path to create the service.
  path?: string;
  // The name of the project.
  project?: string;
}

添加模板文件

要把工件添加到项目中，你的原理图就需要自己的模板文件。原理图模板支持特殊的语法来执行代码和变量替换。

1. 在 ​schematics/my-service/​ 目录下创建一个 ​files/​ 文件夹。
2. 创建一个名叫 ​__name@dasherize__.service.ts.template​ 的文件，它定义了一个可以用来生成文件的模板。这里的模板会生成一个已把 Angular 的 ​HttpClient ​注入到其构造函数中的服务。

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
@Injectable({
  providedIn: 'root'
})
export class <%= classify(name) %>Service {
  constructor(private http: HttpClient) { }
}

• ​classify ​和 ​dasherize ​方法是实用函数，你的原理图会用它们来转换你的模板源码和文件名。
• ​name ​是工厂函数提供的一个属性。它与你在模式中定义的 ​name ​是一样的。

添加工厂函数

现在，你已经有了基础设施，可以开始定义一个 main 函数来执行要对用户项目做的各种修改了。

Schematics 框架提供了一个文件模板系统，它支持路径和内容模板。系统会操作在这个输入文件树（​Tree​）中加载的文件内或路径中定义的占位符，用传给 ​Rule ​的值来填充它们。

关于这些数据结构和语法的详细信息，请参阅 Schematics 的 README。

1. 创建主文件 ​index.ts​ 并为你的原理图工厂函数添加源代码。
2. 首先，导入你需要的原理图定义。Schematics 框架提供了许多实用函数来创建规则或在执行原理图时和使用规则。

import {
  Rule, Tree, SchematicsException,
  apply, url, applyTemplates, move,
  chain, mergeWith
} from '@angular-devkit/schematics';
import { strings, normalize, virtualFs, workspaces } from '@angular-devkit/core';

import {
  Rule, Tree, SchematicsException,
  apply, url, applyTemplates, move,
  chain, mergeWith
} from '@angular-devkit/schematics';
import { strings, normalize, virtualFs, workspaces } from '@angular-devkit/core';
import { Schema as MyServiceSchema } from './schema';

export function myService(options: MyServiceSchema): Rule {
  return (tree: Tree) => tree;
}

这个规则工厂返回树而不做任何修改。这些选项都是从 ​ng generate​ 命令传过来的选项值。

定义一个生成器规则

你现在有了一个框架，可用来创建一些真正修改用户程序的代码，以便对库中定义的服务进行设置。

用户安装过此库的 Angular 工作区中会包含多个项目（应用和库）。用户可以在命令行中指定一个项目，也可以使用它的默认值。在任何一种情况下，你的代码都需要知道应该在哪个项目上应用此原理图，这样才能从该项目的配置中检索信息。

可以使用传给工厂函数的 ​Tree ​对象来做到这一点。通过 ​Tree ​的一些方法，你可以访问此工作区的完整文件树，以便在运行原理图时读写文件。

获取项目配置

1. 要确定目标项目，可以使用 ​workspaces.readWorkspace​ 方法在工作区的根目录下读取工作区配置文件 ​angular.json​ 的内容。要想使用 ​workspaces.readWorkspace​，你要先从这个 ​Tree ​创建出一个 ​workspaces.WorkspaceHost​。将以下代码添加到工厂函数中。

import {
  Rule, Tree, SchematicsException,
  apply, url, applyTemplates, move,
  chain, mergeWith
} from '@angular-devkit/schematics';
import { strings, normalize, virtualFs, workspaces } from '@angular-devkit/core';
import { Schema as MyServiceSchema } from './schema';
function createHost(tree: Tree): workspaces.WorkspaceHost {
  return {
    async readFile(path: string): Promise<string> {
      const data = tree.read(path);
      if (!data) {
        throw new SchematicsException('File not found.');
      }
      return virtualFs.fileBufferToString(data);
    },
    async writeFile(path: string, data: string): Promise<void> {
      return tree.overwrite(path, data);
    },
    async isDirectory(path: string): Promise<boolean> {
      return !tree.exists(path) && tree.getDir(path).subfiles.length > 0;
    },
    async isFile(path: string): Promise<boolean> {
      return tree.exists(path);
    },
  };
}
export function myService(options: MyServiceSchema): Rule {
  return async (tree: Tree) => {
    const host = createHost(tree);
    const { workspace } = await workspaces.readWorkspace('/', host);
  };
}

一定要检查此上下文是否存在，并抛出相应的错误。

const project = (options.project != null) ? workspace.projects.get(options.project) : null;
if (!project) {
  throw new SchematicsException(`Invalid project name: ${options.project}`);
}
const projectType = project.extensions.projectType === 'application' ? 'app' : 'lib';

此 ​workspace.projects​ 对象包含指定项目的全部配置信息。

原理图模式中的 ​path ​选项默认会替换为当前工作目录。如果未定义 ​path​，就使用项目配置中的 ​sourceRoot ​和 ​projectType ​来确定。

if (options.path === undefined) {
  options.path = `${project.sourceRoot}/${projectType}`;
}

定义规则

​Rule ​可以使用外部模板文件，对它们进行转换，并使用转换后的模板返回另一个 ​Rule ​对象。可以用模板来生成原理图所需的任意自定义文件。

1. 将以下代码添加到工厂函数中。

const templateSource = apply(url('./files'), [
  applyTemplates({
    classify: strings.classify,
    dasherize: strings.dasherize,
    name: options.name
  }),
  move(normalize(options.path as string))
]);

return chain([
  mergeWith(templateSource)
]);

该 ​chain()​ 方法允许你把多个规则组合到一个规则中，这样就可以在一个原理图中执行多个操作。这里你只是把模板规则和原理图要执行的代码合并在一起。

请看原理图规则函数的一个完整例子。

import {
  Rule, Tree, SchematicsException,
  apply, url, applyTemplates, move,
  chain, mergeWith
} from '@angular-devkit/schematics';
import { strings, normalize, virtualFs, workspaces } from '@angular-devkit/core';
import { Schema as MyServiceSchema } from './schema';
function createHost(tree: Tree): workspaces.WorkspaceHost {
  return {
    async readFile(path: string): Promise<string> {
      const data = tree.read(path);
      if (!data) {
        throw new SchematicsException('File not found.');
      }
      return virtualFs.fileBufferToString(data);
    },
    async writeFile(path: string, data: string): Promise<void> {
      return tree.overwrite(path, data);
    },
    async isDirectory(path: string): Promise<boolean> {
      return !tree.exists(path) && tree.getDir(path).subfiles.length > 0;
    },
    async isFile(path: string): Promise<boolean> {
      return tree.exists(path);
    },
  };
}
export function myService(options: MyServiceSchema): Rule {
  return async (tree: Tree) => {
    const host = createHost(tree);
    const { workspace } = await workspaces.readWorkspace('/', host);
    const project = (options.project != null) ? workspace.projects.get(options.project) : null;
    if (!project) {
      throw new SchematicsException(`Invalid project name: ${options.project}`);
    }
    const projectType = project.extensions.projectType === 'application' ? 'app' : 'lib';
    if (options.path === undefined) {
      options.path = `${project.sourceRoot}/${projectType}`;
    }
    const templateSource = apply(url('./files'), [
      applyTemplates({
        classify: strings.classify,
        dasherize: strings.dasherize,
        name: options.name
      }),
      move(normalize(options.path as string))
    ]);
    return chain([
      mergeWith(templateSource)
    ]);
  };
}

关于规则和实用工具方法的详细信息，请参阅预定义规则。

运行你的库原理图

在构建库和原理图之后，你就可以安装一个原理图集合来运行你的项目了。下面的步骤介绍了如何使用上面创建的原理图来生成服务。

构建你的库和原理图

在工作区的根目录下，运行库的 ​ng build​ 命令。

ng build my-lib

然后，进入库目录，构建原理图

cd projects/my-lib
npm run build

链接这个库

这些库和原理图都已打包好了，就放在你工作区根目录下的 ​dist/my-lib​ 文件夹中。要运行这个原理图，你需要把这个库链接到 ​node_modules ​文件夹中。在工作区的根目录下，运行 ​npm link​ 命令，并把你的可分发库的路径作为参数。

npm link dist/my-lib

运行原理图

现在你的库已经安装完毕，可以使用 ​ng generate​ 命令来运行原理图了。

ng generate my-lib:my-service --name my-data

在控制台中，你会看到原理图已经运行过了，​my-data.service.ts​ 文件被创建在了你的 app 文件夹中。

CREATE src/app/my-data.service.ts (208 bytes)