Merge remote-tracking branch 'abpframework/dev' into dev

docs/en/Customizing-Application-Modules-Overriding-Services.md

@@ -60,6 +60,7 @@ In most cases, you will want to change one or a few methods of the current imple
 
 ````csharp
 [Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IIdentityUserAppService), typeof(IdentityUserAppService))]
 public class MyIdentityUserAppService : IdentityUserAppService
 {
     //...
@@ -262,4 +263,4 @@ See [Overriding the User Interface](Customizing-Application-Modules-Overriding-U
 
 ## How to Find the Services?
 
-[Module documents](Modules/Index.md) includes the list of the major services they define. In addition, you can investigate [their source code](https://github.com/abpframework/abp/tree/dev/modules) to explore all the services.
+[Module documents](Modules/Index.md) includes the list of the major services they define. In addition, you can investigate [their source code](https://github.com/abpframework/abp/tree/dev/modules) to explore all the services.

docs/en/Nightly-Builds.md

@@ -24,3 +24,18 @@ Now, you can install preview / nightly packages to your project from Nuget Brows
 3. Search a package. You will see prereleases of the package formatted as `(VERSION)-preview(DATE)` (like *v0.16.0-preview20190401* in this sample).
 4. You can click to the `Install` button to add package to your project.
 
+## Install & Uninstall Preview NPM Packages
+
+The latest version of preview NPM packages can be installed by the running below command in the root folder of application:
+
+```bash
+abp switch-to-preview
+```
+
+If you're using the ABP Framework preview packages, you can switch back to stable version using this command:
+
+```bash
+abp switch-to-stable
+```
+
+See the [ABP CLI documentation](./CLI.md) for more information.

docs/en/Tutorials/Part-1.md

@@ -22,7 +22,7 @@ end
 
 ### About this tutorial:
 
-In this tutorial series, you will build an ABP Commercial application named `Acme.BookStore`. In this sample project, we will manage a list of books and authors. **{{DB_Text}}** will be used as the ORM provider. And on the front-end side {{UI_Value}} and JavaScript will be used.
+In this tutorial series, you will build an ABP application named `Acme.BookStore`. In this sample project, we will manage a list of books and authors. **{{DB_Text}}** will be used as the ORM provider. And on the front-end side {{UI_Value}} and JavaScript will be used.
 
 The ASP.NET Core {{UI_Value}} tutorial series consists of 3 parts:
 
@@ -34,11 +34,11 @@ The ASP.NET Core {{UI_Value}} tutorial series consists of 3 parts:
 
 ### Creating the project
 
-Create a new project named `Acme.BookStore` where `Acme` is the company name and `BookStore` is the project name. You can check out [creating a new project](../Getting-Started-{{if UI == 'NG'}}Angular{{else}}AspNetCore-MVC{{end}}-Template#creating-a-new-project) document to see how you can create a new project.  We will create the project with ABP CLI. But first of all, we need to login to the ABP Platform to create a commercial project.
+Create a new project named `Acme.BookStore` where `Acme` is the company name and `BookStore` is the project name. You can check out [creating a new project](../Getting-Started-{{if UI == 'NG'}}Angular{{else}}AspNetCore-MVC{{end}}-Template#creating-a-new-project) document to see how you can create a new project.  We will create the project with ABP CLI. But first of all, we need to login to the ABP Platform.
 
 #### Create the project
 
-By running the below command, it creates a new ABP Commercial project with the database provider `{{DB_Text}}` and UI option `MVC`. To see the other CLI options, check out [ABP CLI](https://docs.abp.io/en/abp/latest/CLI) document.
+By running the below command, it creates a new ABP project with the database provider `{{DB_Text}}` and UI option `MVC`. To see the other CLI options, check out [ABP CLI](https://docs.abp.io/en/abp/latest/CLI) document.
 
 ```bash
 abp new Acme.BookStore --template app --database-provider {{DB}} --ui {{UI_Text}}

docs/en/UI/Angular/Dom-Insertion-Service.md

@@ -35,17 +35,19 @@ class DemoComponent {
   constructor(private domInsertionService: DomInsertionService) {}
 
   ngOnInit() {
-    this.domInsertionService.insertContent(
+    const scriptElement = this.domInsertionService.insertContent(
       CONTENT_STRATEGY.AppendScriptToBody('alert()')
     );
   }
 }
 ```
 
-In the example above, `<script>alert()</script>` element will place at the **end** of `<body>`.
+In the example above, `<script>alert()</script>` element will place at the **end** of `<body>` and `scriptElement` will be an `HTMLScriptElement`.
 
 Please refer to [ContentStrategy](./Content-Strategy.md) to see all available content strategies and how you can build your own content strategy.
 
+> Important Note: `DomInsertionService` does not insert the same content twice. In order to add a content again, you first should remove the old content using `removeContent` method.
+
 ### How to Insert Styles
 
 If you pass a `StyleContentStrategy` instance as the first parameter of `insertContent` method, the `DomInsertionService` will create a `<style>` element with given `content` and place it in the designated DOM position.
@@ -60,27 +62,68 @@ class DemoComponent {
   constructor(private domInsertionService: DomInsertionService) {}
 
   ngOnInit() {
-    this.domInsertionService.insertContent(
+    const styleElement = this.domInsertionService.insertContent(
       CONTENT_STRATEGY.AppendStyleToHead('body {margin: 0;}')
     );
   }
 }
 ```
 
-In the example above, `<style>body {margin: 0;}</style>` element will place at the **end** of `<head>`.
+In the example above, `<style>body {margin: 0;}</style>` element will place at the **end** of `<head>` and `styleElement` will be an `HTMLStyleElement`.
 
 Please refer to [ContentStrategy](./Content-Strategy.md) to see all available content strategies and how you can build your own content strategy.
 
+> Important Note: `DomInsertionService` does not insert the same content twice. In order to add a content again, you first should remove the old content using `removeContent` method.
+
+### How to Remove Inserted Scripts & Styles
+
+If you pass the inserted `HTMLScriptElement` or `HTMLStyleElement` element as the first parameter of `removeContent` method, the `DomInsertionService` will remove the given element.
+
+```js
+import { DomInsertionService, CONTENT_STRATEGY } from '@abp/ng.core';
+
+@Component({
+  /* class metadata here */
+})
+class DemoComponent {
+  private styleElement: HTMLStyleElement;
+
+  constructor(private domInsertionService: DomInsertionService) {}
+
+  ngOnInit() {
+    this.styleElement = this.domInsertionService.insertContent(
+      CONTENT_STRATEGY.AppendStyleToHead('body {margin: 0;}')
+    );
+  }
+
+  ngOnDestroy() {
+    this.domInsertionService.removeContent(this.styleElement);
+  }
+}
+```
+
+In the example above, `<style>body {margin: 0;}</style>` element **will be removed** from `<head>` when the component is destroyed.
+
 ## API
 
 ### insertContent
 
 ```js
-insertContent(contentStrategy: ContentStrategy): void
+insertContent<T extends HTMLScriptElement | HTMLStyleElement>(
+  contentStrategy: ContentStrategy<T>,
+): T
 ```
 
 - `contentStrategy` parameter is the primary focus here and is explained above.
+- returns `HTMLScriptElement` or `HTMLStyleElement` based on given strategy.
+
+### removeContent
+
+```js
+removeContent(element: HTMLScriptElement | HTMLStyleElement): void
+```
 
+- `element` parameter is the inserted `HTMLScriptElement` or `HTMLStyleElement` element, which was returned by `insertContent` method.
 
 ## What's Next?
 

docs/en/UI/AspNetCore/Tag-Helpers/List-Groups.md

@@ -19,7 +19,7 @@ Basic usage:
 
 ## Demo
 
-See the [list groups demo page](https://bootstrap-taghelpers.abp.io/Components/ListGroups) to see it in action.
+See the [list groups demo page](https://bootstrap-taghelpers.abp.io/Components/ListGroup) to see it in action.
 
 ## Attributes
 

docs/en/UI/AspNetCore/Tag-Helpers/Progress-Bars.md

@@ -26,7 +26,7 @@ Basic usage:
 
 ## Demo
 
-See the [progress bars demo page](https://bootstrap-taghelpers.abp.io/Components/Progress-Bars) to see it in action.
+See the [progress bars demo page](https://bootstrap-taghelpers.abp.io/Components/Progressbars) to see it in action.
 
 ## Attributes
 
@@ -67,4 +67,4 @@ A value indicates if the background style of the progress bar is stripped. Shoul
 A value indicates if the stripped background style of the progress bar is animated. Should be one of the following values:
 
 * `false` (default value)
-* `true`
+* `true`

docs/zh-Hans/Customizing-Application-Modules-Overriding-Services.md

@@ -60,6 +60,7 @@ context.Services.Replace(
 
 ````csharp
 [Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IIdentityUserAppService), typeof(IdentityUserAppService))]
 public class MyIdentityUserAppService : IdentityUserAppService
 {
     //...
@@ -262,4 +263,4 @@ ObjectExtensionManager.Instance
 
 ## 如何找到服务?
 
-[模块文档](Modules/Index.md) 包含了定义的主要服务列表. 另外 你也可以查看[源码](https://github.com/abpframework/abp/tree/dev/modules)找到所有的服务.
+[模块文档](Modules/Index.md) 包含了定义的主要服务列表. 另外 你也可以查看[源码](https://github.com/abpframework/abp/tree/dev/modules)找到所有的服务.

docs/zh-Hans/Nightly-Builds.md

@@ -23,3 +23,19 @@
 2. 将包源更改为`全部`.
 3. 搜索nuget包. 你将看到包的预发布格式为`(VERSION)-preview(DATE)` (如本示例中的**v0.16.0-preview20190401**).
 4. 你可以单击`安装`按钮将包添加到项目中.
+
+## 安装和卸载预览NPM包
+
+预览NPM包的最新版本可以通过在应用程序的根文件夹命令运行命令安装:
+
+```bash
+abp switch-to-preview
+```
+
+如果你正在使用ABP框架预览包,你可以使用此命令切换回稳定版本:
+
+```bash
+abp switch-to-stable
+```
+
+参阅 [ABP CLI 文档](./CLI.md) 了解更多信息.

docs/zh-Hans/UI/Angular/Component-Replacement.md

@@ -1,3 +1,84 @@
-# Component Replacement
+## 替换组件
 
-TODO...
+你可以将一些ABP的组件替换为你自己的自定义组件.
+
+您可以**替换**但**不能自定义**默认ABP组件的原因是禁用或更改该组件的一部分可能会导致问题. 所以我们把这些组件称为可替换组件.
+
+### 如何替换组件
+
+创建一个你想要使用的新组件,添加到 `AppModule` 中的 `declarations` 和`entryComponents` 中.
+
+然后打开 `app.component.ts` 使用 `AddReplaceableComponent` 将你的组件替换ABP组件. 如下所示:
+
+```js
+import { ..., AddReplaceableComponent } from '@abp/ng.core'; // imported AddReplaceableComponent action
+import { eIdentityComponents } from '@abp/ng.identity'; // imported eIdentityComponents enum
+import { Store } from '@ngxs/store'; // imported Store
+//...
+export class AppComponent {
+  constructor(..., private store: Store) {} // injected Store
+
+  ngOnInit() {
+    this.store.dispatch(
+      new AddReplaceableComponent({
+        component: YourNewRoleComponent,
+        key: eIdentityComponents.Roles,
+      }),
+    );
+    //...
+  }
+}
+```
+
+![Example Usage](./images/component-replacement.gif)
+
+### 如何替换布局
+
+每个ABP主题模块有3个布局,分别是`ApplicationLayoutComponent`, `AccountLayoutComponent`, `EmptyLayoutComponent`. 这些布局可以用相同的方式替换.
+
+> 一个布局组件模板应该包含 `<router-outlet></router-outlet>` 元素.
+
+下面的例子解释了如何更换 `ApplicationLayoutComponent`:
+
+运行以下命令在 `angular` 文件夹中生成布局:
+
+```bash
+yarn ng generate component shared/my-application-layout --export --entryComponent
+
+# You don't need the --entryComponent option in Angular 9
+```
+
+在你的布局模板(`my-layout.component.html`)中添加以下代码:
+
+```html
+<router-outlet></router-outlet>
+```
+
+打开 `app.component.ts` 添加以下内容:
+
+```js
+import { ..., AddReplaceableComponent } from '@abp/ng.core'; // imported AddReplaceableComponent
+import { eThemeBasicComponents } from '@abp/ng.theme.basic'; // imported eThemeBasicComponents enum for component keys
+import { MyApplicationLayoutComponent } from './shared/my-application-layout/my-application-layout.component'; // imported MyApplicationLayoutComponent
+import { Store } from '@ngxs/store'; // imported Store
+//...
+export class AppComponent {
+  constructor(..., private store: Store) {} // injected Store
+
+  ngOnInit() {
+    // added below content
+    this.store.dispatch(
+      new AddReplaceableComponent({
+        component: MyApplicationLayoutComponent,
+        key: eThemeBasicComponents.ApplicationLayout,
+      }),
+    );
+
+    //...
+  }
+}
+```
+
+## 下一步是什么?
+
+- [自定义设置页面](./Custom-Setting-Page.md)

docs/zh-Hans/UI/Angular/Config-State.md

@@ -0,0 +1,3 @@
+## 配置状态
+
+TODO...

docs/zh-Hans/UI/Angular/Container-Strategy.md

@@ -0,0 +1,87 @@
+# ContainerStrategy
+
+`ContainerStrategy` 是 @abp/ng.core 包暴露出的抽象类. 有两种扩展容器扩展策略: `ClearContainerStrategy` 和 `InsertIntoContainerStrategy`. 它们实现了相同的方法和属性,这两种策略都可以帮助你定义容器的准备方式和内容的投影位置.
+
+## API
+
+`ClearContainerStrategy` 是一个扩展了 `ContainerStrategy` 的类. 它允许你**将内容投影之前清除容器**.
+
+### 构造函数
+
+```js
+constructor(
+  public containerRef: ViewContainerRef,
+  private index?: number, // works only in InsertIntoContainerStrategy
+)
+```
+
+- `containerRef` 是在投影内容时使用的 `ViewContainerRef`.
+
+### getIndex
+
+```js
+getIndex(): number
+```
+
+该方法返回被 `0` 和 `containerRef` `length` 限制的给定索引. 对于没有索引的策略,它返回`0`.
+
+### prepare
+
+```js
+prepare(): void
+```
+
+此方法在内容投影之前调用. 基于使用的容器策略,它要么清除容器,要么什么都不做(空操作).
+
+## ClearContainerStrategy
+
+`ClearContainerStrategy` 是一个扩展了 `ContainerStrategy` 的类. 它允许你**将内容投影之前清除容器**.
+
+## InsertIntoContainerStrategy
+
+`InsertIntoContainerStrategy` 是一个扩展了 `ContainerStrategy` 的类. 它允许你**将内容投影到容器中的特定节点索引上**.
+
+## 预定义的容器策略
+
+可以通过 `CONTAINER_STRATEGY` 常量访问预定义的容器策略.
+
+### Clear
+
+```js
+CONTAINER_STRATEGY.Clear(containerRef: ViewContainerRef)
+```
+
+在内容投影之前清除给定的容器.
+
+
+### Append
+
+```js
+CONTAINER_STRATEGY.Append(containerRef: ViewContainerRef)
+```
+
+将投影内容附加到容器中.
+
+
+### Prepend
+
+```js
+CONTAINER_STRATEGY.Prepend(containerRef: ViewContainerRef)
+```
+
+将投影的内容预先写入容器中.
+
+### Insert
+
+```js
+CONTAINER_STRATEGY.Insert(
+  containerRef: ViewContainerRef,
+  index: number,
+)
+```
+
+将投影内容按照给定的索引(在`0` 到 `containerRef`的长度之间)插入到容器中.
+
+## 另请参阅
+
+- [ProjectionStrategy](./Projection-Strategy.md)

docs/zh-Hans/UI/Angular/Content-Projection-Service.md

@@ -0,0 +1,77 @@
+# 内容投影
+
+你可以使用位于@abp/ng.core包中的 `ContentProjectionService` 简单明确的投影内容.
+
+## 入门
+
+你不必在模块或组件级别提供 `ContentProjectionService`,因为它已经在**根中提供了**. 你可以在组件中注入并开始使用它. 为了获得更好的类型支持,你可以将迭代项目的类型传递给它.
+
+```js
+import { ContentProjectionService } from '@abp/ng.core';
+
+@Component({
+  /* class metadata here */
+})
+class DemoComponent {
+  constructor(private contentProjectionService: ContentProjectionService) {}
+}
+```
+
+## 用法
+
+你可以使用 `ContentProjectionService` 的 `projectContent` 方法在你的项目中动态的渲染组件和模板.
+
+### 如何将组件投影到根级别
+
+如果将 `RootComponentProjectionStrategy` 做为 `projectContent` 方法的第一个参数,那么 `ContentProjectionService` 会解析投影组件并放在根级别,它还为组件传递上下文.
+
+```js
+const strategy = PROJECTION_STRATEGY.AppendComponentToBody(
+  SomeOverlayComponent,
+  { someOverlayProp: "SOME_VALUE" }
+);
+
+const componentRef = this.contentProjectionService.projectContent(strategy);
+```
+
+在上面的示例中, `SomeOverlayComponent` 组件放置在 `<body>` 的**末尾**并返回 `ComponentRef`. 另外将应用给定的上下文,因此组件的 `someOverlayProp` 被设置为 `SOME_VALUE`.
+
+> 你应该总是返回 `ComponentRef` 实例,因为它是对投影组件的引用,在你需要时使用该引用销毁投影视图和组件实例.
+
+### 如何将组件和模板投影到容器中
+
+如果将 `ComponentProjectionStrategy` 或 `TemplateProjectionStrategy` 做为 `projectContent` 方法的第一个参数,并且传递 `ViewContainerRef` 做为策略的第二个参数传递. 那么 `ContentProjectionService` 把组件或模板投影到给定的容器中,它还为组件或模板传递上下文.
+
+```js
+const strategy = PROJECTION_STRATEGY.ProjectComponentToContainer(
+  SomeComponent,
+  viewContainerRefOfTarget,
+  { someProp: "SOME_VALUE" }
+);
+
+const componentRef = this.contentProjectionService.projectContent(strategy);
+```
+
+在上面的示例中,`viewContainerRefOfTarget`(它是一个`ViewContainerRef` 实例)将被清除,并把 `SomeComponent` 组件放在其中. 另外将应用给定的上下文,因此组件的 `someProp` 被设置为 `SOME_VALUE`.
+
+> 你应该总是返回 `ComponentRef` 或 `EmbeddedViewRef` ,因为它是对投影内容的引用,在你需要时使用该引用销毁它们.
+
+请参考[ProjectionStrategy](./Projection-Strategy.md)查看所有可用的投影策略以及如何构建自己的投影策略.
+
+## API
+
+### projectContent
+
+```js
+projectContent<T extends Type<any> | TemplateRef<any>>(
+    projectionStrategy: ProjectionStrategy<T>,
+    injector = this.injector,
+): ComponentRef<C> | EmbeddedViewRef<C>
+```
+
+- `projectionStrategy` 参数是此处的要点,在上面进行了说明.
+- `injector` 参数是 `Injector` 实例,你可以传递到投影内容. 在 `TemplateProjectionStrategy` 并没有使用到它.
+
+## 下一步是什么?
+
+- [TrackByService](./Track-By-Service.md)

docs/zh-Hans/UI/Angular/Content-Security-Strategy.md

@@ -0,0 +1,55 @@
+# ContentSecurityStrategy
+
+`ContentSecurityStrategy` 是@abp/ng.core包暴露出的抽象类. 它可以根据[内容安全策略](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy)帮助你将内联脚本或样式标记为安全.
+
+## API
+
+### 构造函数
+
+```js
+constructor(public nonce?: string)
+```
+
+- `nonce` 启用将内联脚本或样式列入白名单,避免在[script-src](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src#Unsafe_inline_script)和[style-src](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/style-src#Unsafe_inline_styles)指令中使用 `unsafe-inline`.
+
+### applyCSP
+
+```js
+applyCSP(element: HTMLScriptElement | HTMLStyleElement): void
+```
+
+该方法将上述属性映射到给定`element`.
+
+## LooseContentSecurityPolicy
+
+`LooseContentSecurityPolicy` 是扩展了 `ContentSecurityStrategy` 的类. 它需要 `nonce` 和带有给定 `<script>` 或 `<style>` 标记的标签.
+
+## NoContentSecurityPolicy
+
+`NoContentSecurityPolicy` 是扩展了 `ContentSecurityStrategy` 的类. 它不会将内联脚本和样式标记为安全. 你可以将其视为空操作的替代方案.
+s
+
+## 预定义内容安全策略
+
+可以通过 `CONTENT_SECURITY_STRATEGY` 常量访问预定义的内容安全策略.
+
+### Loose
+
+```js
+CONTENT_SECURITY_STRATEGY.Loose(nonce: string)
+```
+
+`nonce` 会被设置.
+
+### None
+
+```js
+CONTENT_SECURITY_STRATEGY.None()
+```
+
+什么都不会做.
+
+## 另请参阅
+
+- [DomInsertionService](./Dom-Insertion-Service.md)
+- [ContentStrategy](./Content-Strategy.md)

docs/zh-Hans/UI/Angular/Content-Strategy.md

@@ -0,0 +1,85 @@
+# ContentStrategy
+
+`ContentStrategy` 是@abp/ng.core包暴露出的抽象类. 它可以帮助您创建内联脚本或样式.
+
+## API
+
+### 构造函数
+
+```js
+constructor(
+  public content: string,
+  protected domStrategy?: DomStrategy,
+  protected contentSecurityStrategy?: ContentSecurityStrategy
+)
+```
+
+- `content` 是被设置为 `<script>` 和 `<style>` 元素的 `textContent` 属性.
+- `domStrategy` 是在插入创建的元素时将使用的 `DomStrategy` . (默认值: AppendToHead_)
+- `contentSecurityStrategy` 是 `ContentSecurityStrategy`, 在创建的元素插入使用它它.  (默认值: None_)
+
+请参考[DomStrategy](./Dom-Strategy.md)和[ContentSecurityStrategy](./Content-Security-Strategy.md)文档了解它们的用法.
+
+### createElement
+
+```js
+createElement(): HTMLScriptElement | HTMLStyleElement
+```
+
+该方法创建并且返回 `<script>` 或 `<style>` 元素, 将 `content` 设置为 `textContent`.
+
+### insertElement
+
+```js
+insertElement(): void
+```
+
+该方法创建并且插入一个 `<script>` 或 `<style>` 元素.
+
+## ScriptContentStrategy
+
+`ScriptContentStrategy` 是扩展了 `ContentStrategy` 的类. 你可以使用它将 **`<script>`元素插入DOM**.
+
+## StyleContentStrategy
+
+`StyleContentStrategy` 是扩展了 `ContentStrategy` 的类. 你可以使用它将 **`<style>`元素插入DOM**.
+
+## 预定义内容策略
+
+预定义的内容策略可以通过 `CONTENT_STRATEGY` 常量访问.
+
+### AppendScriptToBody
+
+```js
+CONTENT_STRATEGY.AppendScriptToBody(content: string)
+```
+
+创建具有给定内容的 `<script>` 元素, 并放置在文档中`<body>`标记的**末尾**.
+
+### AppendScriptToHead
+
+```js
+CONTENT_STRATEGY.AppendScriptToHead(content: string)
+```
+
+创建具有给定内容的 `<script>` 元素, 并放置在文档中`<head>`标签的**末尾**.
+
+### AppendStyleToHead
+
+```js
+CONTENT_STRATEGY.AppendStyleToHead(content: string)
+```
+
+创建具有给定内容的 `<style>` 元素, 并放置在文档中`<head>`标签的**末尾**.
+
+### PrependStyleToHead
+
+```js
+CONTENT_STRATEGY.PrependStyleToHead(content: string)
+```
+
+创建具有给定内容的 `<style>` 元素, 并放置在文档中`<head>`标签的**头部**.
+
+## 另请参阅
+
+- [DomInsertionService](./Dom-Insertion-Service.md)

docs/zh-Hans/UI/Angular/Context-Strategy.md

@@ -0,0 +1,100 @@
+# ContextStrategy
+
+`ContextStrategy` 是@abp/ng.core包暴露出的抽象类. 有三种扩展容器扩展策略: `ComponentContextStrategy` , `TemplateContextStrategy` 和 `NoContextStrategy`. 它们实现了相同的方法和属性,这三种策略都可以帮助你获得定义投影内容上下文
+
+## ComponentContextStrategy
+
+`ComponentContextStrategy` 是扩展了 `ContextStrategy` 的类, 它允许你**将上下文传递给一个投影组件**.
+
+### 构造函数
+
+```js
+constructor(public context: Partial<InferredInstanceOf<T>>) {}
+```
+
+- `T` 在这里引用组件类型, 例. `Type<C>`.
+- `InferredInstanceOf` 是 @abp/ng.core 包暴露的实用类型. 它可以推断组件.
+- `context` 是将映射到投影组件的属性.
+
+### setContext
+
+```js
+setContext(componentRef: ComponentRef<InferredInstanceOf<T>>): Partial<InferredInstanceOf<T>>
+```
+
+该方法将上下文的每个属性映射到具有相同名称的组件属性,并调用更改检测.映射后返回上下文.
+
+## TemplateContextStrategy
+
+`TemplateContextStrategy` 是扩展了 `ContextStrategy` 的类. 它允许你**将上下文传递到投影模板**.
+
+### 构造函数
+
+```js
+constructor(public context: Partial<InferredContextOf<T>>) {}
+```
+
+- `T` 在这里引用组件类型, 例. `Type<C>`.
+- `InferredInstanceOf` 是 @abp/ng.core 包暴露的实用类型. 它可以推断组件.
+- `context` 是将映射到投影组件的属性.
+
+### setContext
+
+```js
+setContext(): Partial<InferredContextOf<T>>
+```
+
+此方法不执行任何操作它仅返回上下文,因为模板上下文没有被映射. 而是作为参数传递给 `createEmbeddedView` 方法.
+
+## NoContextStrategy
+
+`NoContextStrategy` 是扩展了 `ContextStrategy` 的类. 它允许你**跳过将任何上下文传递到投影内容**.
+
+### 构造函数
+
+```js
+constructor()
+```
+
+不像其它的策略, `NoContextStrategy` 构造函数没有参数.
+
+### setContext
+
+```js
+setContext(): undefined
+```
+
+由于没有上下文,方法没有参数并且返回`undefined`.
+
+## 预定义上下文策略
+
+可以通过 `CONTEXT_STRATEGY` 常量访问预定义的上下文策略.
+
+### None
+
+```js
+CONTEXT_STRATEGY.None()
+```
+
+该策略不会将任何上下文传递到投影内容。
+
+### Component
+
+```js
+CONTEXT_STRATEGY.Component(context: Partial<InferredContextOf<T>>)
+```
+
+该策略将帮助你将给定的上下文传递到投影组件.
+
+
+### Template
+
+```js
+CONTEXT_STRATEGY.Template(context: Partial<InferredContextOf<T>>)
+```
+
+该策略将帮助你将给定的上下文传递到投影模板.
+
+## 另请参阅
+
+- [ProjectionStrategy](./Projection-Strategy.md)

docs/zh-Hans/UI/Angular/Custom-Setting-Page.md

@@ -0,0 +1,46 @@
+# 自定义设置页面
+
+不同的模块提供它们的设置选项卡. 你可以通过3个步骤在项目中自定义设置页面.
+
+1. 创建一个组件
+
+```js
+import { Select } from '@ngxs/store';
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-your-custom-settings',
+  template: `
+    custom-settings works! 
+  `,
+})
+export class YourCustomSettingsComponent {
+  // Your component logic
+}
+```
+
+2. 添加 `YourCustomSettingsComponent` 到 `AppModule` 中的 `declarations`和 `entryComponents` 数组中.
+
+3. 打开 `app.component.ts` 在 `ngOnInit` 添加以下内容:
+
+```js
+import { addSettingTab } from '@abp/ng.theme.shared';
+// ...
+
+ngOnInit() {
+  addSettingTab({
+    component: YourCustomSettingsComponent,
+    name: 'Type here the setting tab title (you can type a localization key, e.g: AbpAccount::Login',
+    order: 4,
+    requiredPolicy: 'type here a policy key'
+  });
+}
+```
+
+导航到 `/setting-management` 路由你会看到以下变化:
+
+![Custom Settings Tab](./images/custom-settings.png)
+
+## 下一步是什么?
+
+- [懒加载 Scripts 与 Styles](./Lazy-Load-Service.md)

docs/zh-Hans/UI/Angular/Dom-Insertion-Service.md

@@ -0,0 +1,3 @@
+# Dom插入(Scripts与Styles)
+
+TODO...

docs/zh-Hans/UI/Angular/Dom-Strategy.md

@@ -0,0 +1,80 @@
+# DomStrategy
+
+`DomStrategy` 是@abp/ng.core包暴露出的抽象类. 它的实例定义了如何将元素附加到DOM以及如何被其它类(如`LoadingStrategy`)使用.
+
+## API
+
+### 构造函数
+
+```js
+constructor(
+  public target?: HTMLElement,
+  public position?: InsertPosition
+)
+```
+
+- `target` 是一个 HTMLElement (默认值: document.head_).
+- `position` 定义将创建的元素放置在何处. 可以在[此处](https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentElement)找到所有可能的 `position` 值(默认值: 'beforeend'_).
+
+### insertElement
+
+```js
+insertElement(element: HTMLElement): void
+```
+
+该方法根据 `postion` 将给定 `元素` 插入到目标中.
+
+## 预定义DOM策略
+
+可以通过 `DOM_STRATEGY` 常量访问预定义的dom策略.
+
+
+### AppendToBody
+
+```js
+DOM_STRATEGY.AppendToBody()
+```
+
+`insertElement` 将给定 `元素` 放在 `<body>` 的末尾.
+
+
+### AppendToHead
+
+```js
+DOM_STRATEGY.AppendToHead()
+```
+
+`insertElement` 将给定 `元素` 放在 `<head>` 的末尾.
+
+### PrependToHead
+
+```js
+DOM_STRATEGY.PrependToHead()
+```
+
+`insertElement` 将给定 `元素` 放在 `<head>` 的头部.
+
+
+### AfterElement
+
+```js
+DOM_STRATEGY.AfterElement(target: HTMLElement)
+```
+
+`insertElement` 将给定 `元素` 放在 `target` 之后 (做为同级元素).
+
+### BeforeElement
+
+```js
+DOM_STRATEGY.BeforeElement(target: HTMLElement)
+```
+
+`insertElement` 将给定 `元素` 放在 `target` 之前 (做为同级元素).
+
+## 另请参阅
+
+- [DomInsertionService](./Dom-Insertion-Service.md)
+- [LazyLoadService](./Lazy-Load-Service.md)
+- [LoadingStrategy](./Loading-Strategy.md)
+- [ContentStrategy](./Content-Strategy.md)
+- [ProjectionStrategy](./Projection-Strategy.md)

docs/zh-Hans/UI/Angular/HTTP-Requests.md

@@ -0,0 +1,3 @@
+## HTTP请求
+
+TODO...

docs/zh-Hans/UI/Angular/Lazy-Load-Service.md

@@ -0,0 +1,3 @@
+# 如何懒加载 Scripts 与 Styles
+
+TODO...

docs/zh-Hans/UI/Angular/Service-Proxies.md

@@ -0,0 +1,3 @@
+## 服务代理
+
+TODO...

docs/zh-Hans/UI/Angular/Track-By-Service.md

@@ -0,0 +1,98 @@
+# 轻松实现TrackByFunction
+
+`TrackByService` 是一个实用服务,为Angular模板中最常见的需求之一: `TrackByFunction` 提供简单的实现. 在继续下面的内容之前,请参先阅 [Angular 文档](https://angular.io/guide/template-syntax#ngfor-with-trackby).
+
+## 入门
+
+你不必在模块或组件级别提供 `TrackByService`,因为它已经在**根中提供了**. 你可以在组件中注入并开始使用它. 为了获得更好的类型支持,你可以将迭代项目的类型传递给它.
+
+```js
+import { TrackByService } from '@abp/ng.core';
+
+@Component({
+  /* class metadata here */
+})
+class DemoComponent {
+  list: Item[];
+
+  constructor(public readonly track: TrackByService<Item>) {}
+}
+```
+
+> 注意到 `track` 是 `public` 并且 `readonly` 了吗? 因为我们将看到一些在组件模板中直接使用 `TrackByService` 实例的方法示例. 可以把它看做反模式,但它有自身的优势,尤其是在利用组件继承时. 你始终可以使用公共组件属性.
+
+**成员也被导出做为独立的函数.** 如果你不想注入 `TrackByService`, 你可以直接在类中导入并使用这些函数.
+
+## 用法
+
+有两种方法可用.
+
+1. 你可以直接注入 `TrackByService` 到你的组件并且使用它的成员.
+2. 你可以在直接在组件属性上使用导出的函数.
+
+### 如何通过一个键跟踪项
+
+你可以使用 `by` 获取一个 `TrackByFunction` , 该函数根据它的一个键来跟踪迭代的对象. 你可以将迭代类型传递给它获得类型支持.
+
+```html
+<!-- template of DemoComponent -->
+
+<div *ngFor="let item of list; trackBy: track.by('id')">{%{{{ item.name }}}%}</div>
+```
+
+`by` 作为一个独立函数导出,命名为 `trackBy`.
+
+```js
+import { trackBy } from "@abp/ng.core";
+
+@Component({
+  template: `
+    <div
+      *ngFor="let item of list; trackBy: trackById"
+    >
+      {%{{{ item.name }}}%}
+    </div>
+  `,
+})
+class DemoComponent {
+  list: Item[];
+
+  trackById = trackBy<Item>('id');
+}
+```
+
+### 如何通过深度嵌套的键进行跟踪
+
+你可以使用 `byDeep` 获取一个 `TrackByFunction` , 它根据深度嵌套的键跟踪迭代对象. 你可以将迭代类型传递给它获得类型支持.
+
+
+```html
+<!-- template of DemoComponent -->
+
+<div
+  *ngFor="let item of list; trackBy: track.byDeep('tenant', 'account', 'id')"
+>
+  {%{{{ item.tenant.name }}}%}
+</div>
+```
+
+`byDeep` 作为一个独立函数导出,命名为 `trackByDeep`.
+
+```js
+import { trackByDeep } from "@abp/ng.core";
+
+@Component({
+  template: `
+    <div
+      *ngFor="let item of list; trackBy: trackByTenantAccountId"
+    >
+      {%{{{ item.name }}}%}
+    </div>
+  `,
+})
+class DemoComponent {
+  list: Item[];
+
+  trackByTenantAccountId = trackByDeep<Item>('tenant', 'account', 'id');
+}
+```

docs/zh-Hans/docs-nav.json

@@ -308,6 +308,14 @@
         {
           "text": "Angular",
           "items": [
+            {
+              "text": "服务代理",
+              "path": "UI/Angular/Service-Proxies.md"
+            },
+            {
+              "text": "HTTP请求",
+              "path": "UI/Angular/HTTP-Requests.md"
+            },
             {
               "text": "本地化",
               "path": "UI/Angular/Localization.md"
@@ -316,9 +324,33 @@
               "text": "权限管理",
               "path": "UI/Angular/Permission-Management.md"
             },
+            {
+              "text": "配置状态",
+              "path": "UI/Angular/Config-State.md"
+            },
             {
               "text": "替换组件",
               "path": "UI/Angular/Component-Replacement.md"
+            },
+            {
+              "text": "自定义设置页",
+              "path": "UI/Angular/Custom-Setting-Page.md"
+            },
+            {
+              "text": "懒加载Scripts与Styles",
+              "path": "UI/Angular/Lazy-Load-Service.md"
+            },
+            {
+              "text": "DomInsertionService",
+              "path": "UI/Angular/Dom-Insertion-Service.md"
+            },
+            {
+              "text": "ContentProjectionService",
+              "path": "UI/Angular/Content-Projection-Service.md"
+            },
+            {
+              "text": "TrackByService",
+              "path": "UI/Angular/Track-By-Service.md"
             }
           ]
         },

framework/src/Volo.Abp.AspNetCore.Mvc.UI.Bootstrap/TagHelpers/Pagination/AbpPaginationTagHelperService.cs

@@ -155,7 +155,7 @@ namespace Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Pagination
             var localizer = _tagHelperLocalizer.GetLocalizer(typeof(AbpUiResource));
 
             var pagerInfo = (TagHelper.ShowInfo ?? false) ?
-                "    <div class=\"col-sm-12 col-md-5\"> " + localizer["PagerInfo", TagHelper.Model.ShowingFrom, TagHelper.Model.ShowingTo, TagHelper.Model.TotalItemsCount] + "</div>\r\n"
+                "    <div class=\"col-sm-12 col-md-5\"> " + localizer["PagerInfo{0}{1}{2}", TagHelper.Model.ShowingFrom, TagHelper.Model.ShowingTo, TagHelper.Model.TotalItemsCount] + "</div>\r\n"
                 : "";
 
             return

framework/src/Volo.Abp.AspNetCore.Mvc.UI.Packages/Volo/Abp/AspNetCore/Mvc/UI/Packages/Core/CoreScriptContributor.cs

@@ -1,8 +1,11 @@
 using System.Collections.Generic;
 using Volo.Abp.AspNetCore.Mvc.UI.Bundling;
+using Volo.Abp.AspNetCore.Mvc.UI.Packages.Utils;
+using Volo.Abp.Modularity;
 
 namespace Volo.Abp.AspNetCore.Mvc.UI.Packages.Core
 {
+    [DependsOn(typeof(UtilsScriptContributor))]
     public class CoreScriptContributor : BundleContributor
     {
         public override void ConfigureBundle(BundleConfigurationContext context)

framework/src/Volo.Abp.AspNetCore.Mvc.UI.Packages/Volo/Abp/AspNetCore/Mvc/UI/Packages/Select2/Select2ScriptContributor.cs

@@ -12,6 +12,7 @@ namespace Volo.Abp.AspNetCore.Mvc.UI.Packages.Select2
         {
             //TODO: Add select2.full.min.js or localize!
             context.Files.AddIfNotContains("/libs/select2/js/select2.min.js");
+            context.Files.AddIfNotContains("/libs/select2/js/select2-bootstrap-modal-patch.js");
         }
     }
 }

framework/src/Volo.Abp.AspNetCore.Mvc.UI.Packages/Volo/Abp/AspNetCore/Mvc/UI/Packages/Utils/UtilsScriptContributor.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using Volo.Abp.AspNetCore.Mvc.UI.Bundling;
+
+namespace Volo.Abp.AspNetCore.Mvc.UI.Packages.Utils
+{
+    public class UtilsScriptContributor : BundleContributor
+    {
+        public override void ConfigureBundle(BundleConfigurationContext context)
+        {
+            context.Files.AddIfNotContains("/libs/abp/utils/abp-utils.umd.min.js");
+        }
+    }
+}

framework/src/Volo.Abp.AspNetCore.TestBase/Volo/Abp/AspNetCore/TestBase/AbpAspNetCoreTestBaseModule.cs

@@ -1,10 +1,13 @@
-using Volo.Abp.Http.Client;
+using Volo.Abp.Autofac;
+using Volo.Abp.Http.Client;
 using Volo.Abp.Modularity;
 
 namespace Volo.Abp.AspNetCore.TestBase
 {
     [DependsOn(typeof(AbpHttpClientModule))]
     [DependsOn(typeof(AbpAspNetCoreModule))]
+    [DependsOn(typeof(AbpTestBaseModule))]
+    [DependsOn(typeof(AbpAutofacModule))]
     public class AbpAspNetCoreTestBaseModule : AbpModule
     {
 

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/CliUrls.cs

@@ -3,19 +3,27 @@
     public static class CliUrls
     {
 #if DEBUG
-        public const string WwwAbpIo = "https://localhost:44328/";
+        public const string WwwAbpIo = WwwAbpIoDevelopment;
 
-        public const string AccountAbpIo = "https://localhost:44333/";
+        public const string AccountAbpIo = AccountAbpIoDevelopment;
 
-        public const string NuGetRootPath = "https://localhost:44373/";
+        public const string NuGetRootPath = NuGetRootPathDevelopment;
 #else
-        public const string WwwAbpIo = "https://abp.io/";
+        public const string WwwAbpIo = WwwAbpIoProduction;
         
-        public const string AccountAbpIo = "https://account.abp.io/";
+        public const string AccountAbpIo = AccountAbpIoProduction;
        
-        public const string NuGetRootPath = "https://nuget.abp.io/";
+        public const string NuGetRootPath = NuGetRootPathProduction;
 #endif
 
+        public const string WwwAbpIoProduction = "https://abp.io/";
+        public const string AccountAbpIoProduction = "https://account.abp.io/";
+        public const string NuGetRootPathProduction = "https://nuget.abp.io/";
+
+        public const string WwwAbpIoDevelopment = "https://localhost:44328/";
+        public const string AccountAbpIoDevelopment = "https://localhost:44333/";
+        public const string NuGetRootPathDevelopment = "https://localhost:44373/";
+
         public static string GetNuGetServiceIndexUrl(string apiKey)
         {
             return $"{NuGetRootPath}{apiKey}/v3/index.json";

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectBuilding/AbpIoSourceCodeStore.cs

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
+using System.Reflection;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
@@ -52,10 +53,15 @@ namespace Volo.Abp.Cli.ProjectBuilding
             string version = null,
             string templateSource = null)
         {
-
             DirectoryHelper.CreateIfNotExists(CliPaths.TemplateCache);
-            
-            var latestVersion = await GetLatestSourceCodeVersionAsync(name, type);
+
+            string latestVersion;
+
+#if DEBUG
+            latestVersion = await GetLatestSourceCodeVersionAsync(name, type, $"{CliUrls.WwwAbpIoProduction}api/download/{type}/get-version/");
+#else
+            latestVersion = await GetLatestSourceCodeVersionAsync(name, type);
+#endif
             if (version == null)
             {
                 if (latestVersion == null)
@@ -64,7 +70,7 @@ namespace Volo.Abp.Cli.ProjectBuilding
                     Logger.LogWarning(string.Empty);
                     Logger.LogWarning("Find the following template in your cache directory: ");
                     Logger.LogWarning("\t Template Name\tVersion");
-                    
+
                     var templateList = GetLocalTemplates();
                     foreach (var cacheFile in templateList)
                     {
@@ -74,12 +80,18 @@ namespace Volo.Abp.Cli.ProjectBuilding
                     Logger.LogWarning(string.Empty);
                     throw new CliUsageException("Use command: abp new Acme.BookStore -v version");
                 }
-                
+
                 version = latestVersion;
             }
 
-            var nugetVersion = (await GetTemplateNugetVersionAsync(name, type, version)) ?? version;
-            
+            string nugetVersion;
+
+#if DEBUG
+            nugetVersion = version;
+#else
+            nugetVersion = (await GetTemplateNugetVersionAsync(name, type, version)) ?? version;
+#endif
+
             if (!string.IsNullOrWhiteSpace(templateSource) && !IsNetworkSource(templateSource))
             {
                 Logger.LogInformation("Using local " + type + ": " + name + ", version: " + version);
@@ -87,6 +99,14 @@ namespace Volo.Abp.Cli.ProjectBuilding
             }
 
             var localCacheFile = Path.Combine(CliPaths.TemplateCache, name + "-" + version + ".zip");
+
+#if DEBUG
+            if (File.Exists(localCacheFile))
+            {
+                return new TemplateFile(File.ReadAllBytes(localCacheFile), version, latestVersion, nugetVersion);
+            }
+#endif
+
             if (Options.CacheTemplates && File.Exists(localCacheFile) && templateSource.IsNullOrWhiteSpace())
             {
                 Logger.LogInformation("Using cached " + type + ": " + name + ", version: " + version);
@@ -111,12 +131,14 @@ namespace Volo.Abp.Cli.ProjectBuilding
             }
 
             return new TemplateFile(fileContent, version, latestVersion, nugetVersion);
-
         }
 
-        private async Task<string> GetLatestSourceCodeVersionAsync(string name, string type)
+        private async Task<string> GetLatestSourceCodeVersionAsync(string name, string type, string url = null)
         {
-            var url = $"{CliUrls.WwwAbpIo}api/download/{type}/get-version/";
+            if (url == null)
+            {
+                url = $"{CliUrls.WwwAbpIo}api/download/{type}/get-version/";
+            }
 
             try
             {
@@ -224,15 +246,15 @@ namespace Volo.Abp.Cli.ProjectBuilding
 
         private List<(string TemplateName, string Version)> GetLocalTemplates()
         {
-            var templateList = new List<(string TemplateName, string Version)>(); 
-            
+            var templateList = new List<(string TemplateName, string Version)>();
+
             var stringBuilder = new StringBuilder();
             foreach (var cacheFile in Directory.GetFiles(CliPaths.TemplateCache))
             {
                 stringBuilder.AppendLine(cacheFile);
             }
 
-            var matches = Regex.Matches(stringBuilder.ToString(),$"({AppTemplate.TemplateName}|{AppProTemplate.TemplateName}|{ModuleTemplate.TemplateName}|{ModuleProTemplate.TemplateName})-(.+).zip");
+            var matches = Regex.Matches(stringBuilder.ToString(), $"({AppTemplate.TemplateName}|{AppProTemplate.TemplateName}|{ModuleTemplate.TemplateName}|{ModuleProTemplate.TemplateName})-(.+).zip");
             foreach (Match match in matches)
             {
                 templateList.Add((match.Groups[1].Value, match.Groups[2].Value));

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectBuilding/TemplateProjectBuilder.cs

@@ -4,6 +4,7 @@ using Microsoft.Extensions.Options;
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
 using Volo.Abp.Cli.Commands;
 using Volo.Abp.Cli.Licensing;
 using Volo.Abp.Cli.ProjectBuilding.Analyticses;
@@ -25,12 +26,15 @@ namespace Volo.Abp.Cli.ProjectBuilding
         protected IJsonSerializer JsonSerializer { get; }
         protected IApiKeyService ApiKeyService { get; }
 
+        private readonly IConfiguration _configuration;
+
         public TemplateProjectBuilder(ISourceCodeStore sourceCodeStore,
             ITemplateInfoProvider templateInfoProvider,
             ICliAnalyticsCollect cliAnalyticsCollect,
             IOptions<AbpCliOptions> options,
             IJsonSerializer jsonSerializer,
-            IApiKeyService apiKeyService)
+            IApiKeyService apiKeyService,
+            IConfiguration configuration)
         {
             SourceCodeStore = sourceCodeStore;
             TemplateInfoProvider = templateInfoProvider;
@@ -38,6 +42,7 @@ namespace Volo.Abp.Cli.ProjectBuilding
             Options = options.Value;
             JsonSerializer = jsonSerializer;
             ApiKeyService = apiKeyService;
+            _configuration = configuration;
 
             Logger = NullLogger<TemplateProjectBuilder>.Instance;
         }
@@ -55,7 +60,30 @@ namespace Volo.Abp.Cli.ProjectBuilding
                 args.TemplateSource
             );
 
-            var apiKeyResult = await ApiKeyService.GetApiKeyOrNullAsync();
+            DeveloperApiKeyResult apiKeyResult = null;
+
+#if DEBUG
+            try
+            {
+                var apiKeyResultSection = _configuration.GetSection("apiKeyResult");
+                if (apiKeyResultSection.Exists())
+                {
+                    apiKeyResult = apiKeyResultSection.Get<DeveloperApiKeyResult>(); //you can use user secrets
+                }
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e);
+            }
+
+            if (apiKeyResult == null)
+            {
+                apiKeyResult = await ApiKeyService.GetApiKeyOrNullAsync();
+            }
+#else
+            apiKeyResult = await ApiKeyService.GetApiKeyOrNullAsync();
+#endif
+
             if (apiKeyResult != null)
             {
                 if (apiKeyResult.ApiKey != null)

framework/src/Volo.Abp.Cli.Core/Volo/Abp/Cli/ProjectModification/NpmPackagesUpdater.cs

@@ -55,7 +55,14 @@ namespace Volo.Abp.Cli.ProjectModification
 
                     if (IsAngularProject(fileDirectory))
                     {
-                        await CreateNpmrcFileAsync(Path.GetDirectoryName(file));
+                        if (includePreviews)
+                        {
+                            await CreateNpmrcFileAsync(Path.GetDirectoryName(file));
+                        }
+                        else if (switchToStable)
+                        {
+                            await DeleteNpmrcFileAsync(Path.GetDirectoryName(file));
+                        }
                     }
 
                     RunYarn(fileDirectory);
@@ -69,11 +76,21 @@ namespace Volo.Abp.Cli.ProjectModification
             }
         }
 
+        private async Task DeleteNpmrcFileAsync(string directoryName)
+        {
+            var fileName = Path.Combine(directoryName, ".npmrc");
+
+            if (File.Exists(fileName))
+            {
+                File.Delete(fileName);
+            }
+        }
+
         private async Task CreateNpmrcFileAsync(string directoryName)
         {
             var fileName = Path.Combine(directoryName, ".npmrc");
 
-            var abpRegistry = "@abp:registry:https://www.myget.org/F/abp-nightly/npm";
+            var abpRegistry = "@abp:registry=https://www.myget.org/F/abp-nightly/npm";
             var voloRegistry = await GetVoloRegistryAsync();
 
             if (File.Exists(fileName))

framework/src/Volo.Abp.Cli/Volo.Abp.Cli.csproj

@@ -1,5 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
-
   <Import Project="..\..\..\configureawait.props" />
   <Import Project="..\..\..\common.props" />
 
@@ -9,6 +9,7 @@
     <PackAsTool>true</PackAsTool>
     <ToolCommandName>abp</ToolCommandName>
     <RootNamespace />
+    <UserSecretsId>43599b00-4fa5-4b9f-a314-0757889b296b</UserSecretsId>
   </PropertyGroup>
 
   <ItemGroup>
@@ -17,11 +18,12 @@
     <PackageReference Include="Serilog.Extensions.Logging" Version="3.0.1" />
     <PackageReference Include="Serilog.Sinks.File" Version="4.1.0" />
     <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="3.1.3" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="3.1.3" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\Volo.Abp.Autofac\Volo.Abp.Autofac.csproj" />
     <ProjectReference Include="..\Volo.Abp.Cli.Core\Volo.Abp.Cli.Core.csproj" />
   </ItemGroup>
-
-</Project>
+</Project>

framework/src/Volo.Abp.Core/Microsoft/Extensions/DependencyInjection/ServiceCollectionConventionalRegistrationExtensions.cs

@@ -13,7 +13,7 @@ namespace Microsoft.Extensions.DependencyInjection
             return services;
         }
 
-        internal static List<IConventionalRegistrar> GetConventionalRegistrars(this IServiceCollection services)
+        public static List<IConventionalRegistrar> GetConventionalRegistrars(this IServiceCollection services)
         {
             return GetOrCreateRegistrarList(services);
         }

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/ar.json

@@ -43,6 +43,7 @@
     "PagerFirst": "الأول",
     "PagerLast": "الاخير",
     "PagerInfo": "عرض _START_ الي _END_ من _TOTAL_ إدخالات",
+    "PagerInfo{0}{1}{2}": "عرض {0} الي {1} من {2} إدخالات",
     "PagerInfoEmpty": "عرض 0 الي 0 من 0 إدخالات",
     "PagerInfoFiltered": "(تمت تصفيته من _MAX_ مجموع الإدخالات)",
     "NoDataAvailableInDatatable": "لا توجد بيانات متاحة في الجدول",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/cs.json

@@ -39,6 +39,7 @@
     "PagerFirst": "První",
     "PagerLast": "Poslední",
     "PagerInfo": "Zobrazeno od _START_ do _END_ z celkem _TOTAL_ záznamů",
+    "PagerInfo{0}{1}{2}": "Zobrazeno od {0} do {1} z celkem {2} záznamů",
     "PagerInfoEmpty": "Zobrazeno od 0 do 0 z celkem 0 záznamů",
     "PagerInfoFiltered": "(filtrováno ze všech _MAX_ záznamů)",
     "NoDataAvailableInDatatable": "V tabulce nejsou žádná data",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/en.json

@@ -43,6 +43,7 @@
     "PagerFirst": "First",
     "PagerLast": "Last",
     "PagerInfo": "Showing _START_ to _END_ of _TOTAL_ entries",
+    "PagerInfo{0}{1}{2}": "Showing {0} to {1} of {2} entries",
     "PagerInfoEmpty": "Showing 0 to 0 of 0 entries",
     "PagerInfoFiltered": "(filtered from _MAX_ total entries)",
     "NoDataAvailableInDatatable": "No data available",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/es.json

@@ -39,6 +39,7 @@
     "PagerFirst": "Primero",
     "PagerLast": "Último",
     "PagerInfo": "Mostrando desde _START_ hasta _END_ total _TOTAL_",
+    "PagerInfo{0}{1}{2}": "Mostrando desde {0} hasta {1} total {2}",
     "PagerInfoEmpty": "Mostrando desde 0 hasta 0 de 0 registros",
     "PagerInfoFiltered": "(filtrado de un total de _MAX_ registros)",
     "NoDataAvailableInDatatable": "No hay datos",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/pl.json

@@ -39,6 +39,7 @@
     "PagerFirst": "Pierwsza",
     "PagerLast": "Ostatnia",
     "PagerInfo": "Pokaż od _START_ do _END_ z _TOTAL_ rekordów",
+    "PagerInfo{0}{1}{2}": "Pokaż od {0} do {1} z {2} rekordów",
     "PagerInfoEmpty": "Pokaż od 0 do 0 z 0 rekordów",
     "PagerInfoFiltered": "(filtruj od _MAX_ wszystkich rekordów)",
     "NoDataAvailableInDatatable": "Nie znaleziono danych w tabeli",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/pt-BR.json

@@ -39,6 +39,7 @@
     "PagerFirst": "Primeira",
     "PagerLast": "Última",
     "PagerInfo": "Mostrando _START_ até _END_ de _TOTAL_ registros",
+    "PagerInfo{0}{1}{2}": "Mostrando {0} até {1} de {2} registros",
     "PagerInfoEmpty": "Mostrando 0 até 0 de 0 registros",
     "PagerInfoFiltered": "(filtrado de um total de _MAX_ registros)",
     "NoDataAvailableInDatatable": "Nenhum dado disponível",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/sl.json

@@ -43,6 +43,7 @@
     "PagerFirst": "Prva",
     "PagerLast": "Zadnja",
     "PagerInfo": "Prikazanih _START_ do _END_ od _TOTAL_ zapisov",
+    "PagerInfo{0}{1}{2}": "Prikazanih {0} do {1} od {2} zapisov",
     "PagerInfoEmpty": "Prikazanih 0 do 0 od 0 zapisov",
     "PagerInfoFiltered": "(filtrirano od vseh _MAX_ zapisov)",
     "NoDataAvailableInDatatable": "V tabeli ni na voljo podatkov",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/tr.json

@@ -43,6 +43,7 @@
     "PagerFirst": "İlk",
     "PagerLast": "Son",
     "PagerInfo": "_TOTAL_ kayıttan _START_ ile _END_ arası gösteriliyor.",
+    "PagerInfo{0}{1}{2}": "{2} kayıttan {0} ile {1} arası gösteriliyor.",
     "PagerInfoEmpty": "0 kayıttan 0 ile 0 arası gösteriliyor.",
     "PagerInfoFiltered": "(_MAX_ kayıt arasından filtrelendi)",
     "NoDataAvailableInDatatable": "Tabloda kayıt mevcut değil.",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/vi.json

@@ -39,6 +39,7 @@
     "PagerFirst": "Trang đầu",
     "PagerLast": "Trang cuối",
     "PagerInfo": "Hiển thị từ _START_ đến _END_ trong _TOTAL_ mục",
+    "PagerInfo{0}{1}{2}": "Hiển thị từ {0} đến {1} trong {2} mục",
     "PagerInfoEmpty": "Hiển thị từ 0 đến 0 trong 0 mục",
     "PagerInfoFiltered": "(được lọc từ tổng số _MAX_ mục)",
     "NoDataAvailableInDatatable": "Không có dữ liệu trong bảng",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/zh-Hans.json

@@ -40,6 +40,7 @@
     "PagerFirst": "首页",
     "PagerLast": "尾页",
     "PagerInfo": "显示 _TOTAL_ 个条目中的 _START_ 到 _END_ 个.",
+    "PagerInfo{0}{1}{2}": "显示 {2} 个条目中的 {0} 到 {1} 个.",
     "PagerInfoEmpty": "显示0个条目中的0到0",
     "PagerInfoFiltered": "(从 _MAX_ 总条目中过滤掉)",
     "NoDataAvailableInDatatable": "表中没有数据",

framework/src/Volo.Abp.UI/Localization/Resources/AbpUi/zh-Hant.json

@@ -39,6 +39,7 @@
     "PagerFirst": "首頁",
     "PagerLast": "末頁",
     "PagerInfo": "顯示 _TOTAL_ 個紀錄的 _START_ 到 _END_ 個.",
+    "PagerInfo{0}{1}{2}": "顯示 {2} 個紀錄的 {0} 到 {1} 個.",
     "PagerInfoEmpty": "顯示0個紀錄中的0到0",
     "PagerInfoFiltered": "(從 _MAX_ 所有紀錄中過濾掉)",
     "NoDataAvailableInDatatable": "資料表中沒有資料",

framework/test/Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.Demo/Pages/Components/FormElements.cshtml

@@ -354,6 +354,14 @@
  public class FormElementsModel : PageModel
     {
         public SampleModel MyModel { get; set; }
+                    
+        public List"SelectListItem" CityList { get; set; } = new List"SelectListItem"
+        {
+            new SelectListItem { Value = "NY", Text = "New York"},
+            new SelectListItem { Value = "LDN", Text = "London"},
+            new SelectListItem { Value = "IST", Text = "Istanbul"},
+            new SelectListItem { Value = "MOS", Text = "Moscow"}
+        };
 
         public void OnGet()
         {

framework/test/Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.Demo/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

framework/test/Volo.Abp.AspNetCore.Mvc.UI.Theme.Basic.Demo/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

modules/account/src/Volo.Abp.Account.Web.IdentityServer/Pages/Consent.cshtml.cs

@@ -188,7 +188,7 @@ namespace Volo.Abp.Account.Web.Pages
             public List<string> GetAllowedScopeNames()
             {
                 var identityScopes = IdentityScopes ?? new List<ConsentModel.ScopeViewModel>();
-                var apiScopes = IdentityScopes ?? new List<ConsentModel.ScopeViewModel>();
+                var apiScopes = ApiScopes ?? new List<ConsentModel.ScopeViewModel>();
                 return identityScopes.Union(apiScopes).Where(s => s.Checked).Select(s => s.Name).ToList();
             }
         }

modules/blogging/app/Volo.BloggingTestApp/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

modules/client-simulation/demo/Volo.ClientSimulation.Demo/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

modules/docs/app/VoloDocs.Web/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

npm/ng-packs/apps/dev-app/src/index.html

@@ -8,6 +8,8 @@
     <link rel="icon" type="image/x-icon" href="favicon.ico" />
   </head>
   <body class="bg-light">
-    <app-root></app-root>
+    <app-root>
+      <div class="donut centered"></div>
+    </app-root>
   </body>
 </html>

npm/ng-packs/apps/dev-app/src/styles.scss

@@ -1 +1,26 @@
 /* You can add global styles to this file, and also import other style files */
+
+@keyframes donut-spin {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+}
+.donut {
+  display: inline-block;
+  border: 4px solid rgba(0, 0, 0, 0.1);
+  border-left-color: #7983ff;
+  border-radius: 50%;
+  width: 30px;
+  height: 30px;
+  animation: donut-spin 1.2s linear infinite;
+
+  &.centered {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+  }
+}

npm/ng-packs/package.json

@@ -22,18 +22,18 @@
     "generate:changelog": "conventional-changelog -p angular -i CHANGELOG.md -s"
   },
   "devDependencies": {
-    "@abp/ng.account": "~2.5.0",
-    "@abp/ng.account.config": "~2.5.0",
-    "@abp/ng.core": "~2.5.0",
-    "@abp/ng.feature-management": "~2.5.0",
-    "@abp/ng.identity": "~2.5.0",
-    "@abp/ng.identity.config": "~2.5.0",
-    "@abp/ng.permission-management": "~2.5.0",
-    "@abp/ng.setting-management": "~2.5.0",
-    "@abp/ng.setting-management.config": "~2.5.0",
-    "@abp/ng.tenant-management": "~2.5.0",
-    "@abp/ng.tenant-management.config": "~2.5.0",
-    "@abp/ng.theme.basic": "~2.5.0",
+    "@abp/ng.account": "^2.5.0",
+    "@abp/ng.account.config": "^2.5.0",
+    "@abp/ng.core": "^2.5.0",
+    "@abp/ng.feature-management": "^2.5.0",
+    "@abp/ng.identity": "^2.5.0",
+    "@abp/ng.identity.config": "^2.5.0",
+    "@abp/ng.permission-management": "^2.5.0",
+    "@abp/ng.setting-management": "^2.5.0",
+    "@abp/ng.setting-management.config": "^2.5.0",
+    "@abp/ng.tenant-management": "^2.5.0",
+    "@abp/ng.tenant-management.config": "^2.5.0",
+    "@abp/ng.theme.basic": "^2.5.0",
     "@abp/ng.theme.shared": "~2.5.0",
     "@abp/utils": "^2.4.0",
     "@angular-builders/jest": "^8.2.0",

npm/ng-packs/packages/core/src/lib/core.module.ts

@@ -9,13 +9,16 @@ import { NgxsModule, NGXS_PLUGINS } from '@ngxs/store';
 import { OAuthModule, OAuthStorage } from 'angular-oauth2-oidc';
 import { AbstractNgModelComponent } from './abstracts/ng-model.component';
 import { DynamicLayoutComponent } from './components/dynamic-layout.component';
+import { ReplaceableRouteContainerComponent } from './components/replaceable-route-container.component';
 import { RouterOutletComponent } from './components/router-outlet.component';
 import { AutofocusDirective } from './directives/autofocus.directive';
 import { InputEventDebounceDirective } from './directives/debounce.directive';
 import { EllipsisDirective } from './directives/ellipsis.directive';
 import { ForDirective } from './directives/for.directive';
 import { FormSubmitDirective } from './directives/form-submit.directive';
+import { InitDirective } from './directives/init.directive';
 import { PermissionDirective } from './directives/permission.directive';
+import { ReplaceableTemplateDirective } from './directives/replaceable-template.directive';
 import { StopPropagationDirective } from './directives/stop-propagation.directive';
 import { VisibilityDirective } from './directives/visibility.directive';
 import { ApiInterceptor } from './interceptors/api.interceptor';
@@ -26,13 +29,11 @@ import { ConfigPlugin, NGXS_CONFIG_PLUGIN_OPTIONS } from './plugins/config.plugi
 import { LocaleProvider } from './providers/locale.provider';
 import { ConfigState } from './states/config.state';
 import { ProfileState } from './states/profile.state';
+import { ReplaceableComponentsState } from './states/replaceable-components.state';
 import { SessionState } from './states/session.state';
+import { CORE_OPTIONS } from './tokens/options.token';
 import { getInitialData, localeInitializer } from './utils/initial-utils';
 import './utils/date-extensions';
-import { ReplaceableRouteContainerComponent } from './components/replaceable-route-container.component';
-import { ReplaceableComponentsState } from './states/replaceable-components.state';
-import { InitDirective } from './directives/init.directive';
-import { ReplaceableTemplateDirective } from './directives/replaceable-template.directive';
 
 export function storageFactory(): OAuthStorage {
   return localStorage;
@@ -111,6 +112,10 @@ export class CoreModule {
         },
         {
           provide: NGXS_CONFIG_PLUGIN_OPTIONS,
+          useValue: { environment: options.environment },
+        },
+        {
+          provide: CORE_OPTIONS,
           useValue: options,
         },
         {

npm/ng-packs/packages/core/src/lib/models/common.ts

@@ -11,6 +11,7 @@ export namespace ABP {
      * @deprecated To be deleted in v3.0
      */
     requirements?: Config.Requirements;
+    skipGetAppConfiguration?: boolean;
   }
 
   export type PagedResponse<T> = {

npm/ng-packs/packages/core/src/lib/services/dom-insertion.service.ts

@@ -6,12 +6,23 @@ import { generateHash } from '../utils';
 export class DomInsertionService {
   readonly inserted = new Set<number>();
 
-  insertContent(contentStrategy: ContentStrategy) {
+  insertContent<T extends HTMLScriptElement | HTMLStyleElement>(
+    contentStrategy: ContentStrategy<T>,
+  ): T {
     const hash = generateHash(contentStrategy.content);
 
     if (this.inserted.has(hash)) return;
 
-    contentStrategy.insertElement();
+    const element = contentStrategy.insertElement();
     this.inserted.add(hash);
+
+    return element;
+  }
+
+  removeContent(element: HTMLScriptElement | HTMLStyleElement) {
+    const hash = generateHash(element.textContent);
+    this.inserted.delete(hash);
+
+    element.parentNode.removeChild(element);
   }
 }

npm/ng-packs/packages/core/src/lib/strategies/content.strategy.ts

@@ -10,11 +10,13 @@ export abstract class ContentStrategy<T extends HTMLScriptElement | HTMLStyleEle
 
   abstract createElement(): T;
 
-  insertElement() {
+  insertElement(): T {
     const element = this.createElement();
 
     this.contentSecurityStrategy.applyCSP(element);
     this.domStrategy.insertElement(element);
+
+    return element;
   }
 }
 

npm/ng-packs/packages/core/src/lib/tests/content.strategy.spec.ts

@@ -1,9 +1,9 @@
 import {
+  CONTENT_SECURITY_STRATEGY,
   CONTENT_STRATEGY,
-  StyleContentStrategy,
-  ScriptContentStrategy,
   DOM_STRATEGY,
-  CONTENT_SECURITY_STRATEGY,
+  ScriptContentStrategy,
+  StyleContentStrategy,
 } from '../strategies';
 import { uuid } from '../utils';
 
@@ -26,8 +26,8 @@ describe('StyleContentStrategy', () => {
       domStrategy.insertElement = jest.fn((el: HTMLScriptElement) => {}) as any;
 
       const strategy = new StyleContentStrategy('', domStrategy, contentSecurityStrategy);
-      const element = strategy.createElement();
-      strategy.insertElement();
+      strategy.createElement();
+      const element = strategy.insertElement();
 
       expect(contentSecurityStrategy.applyCSP).toHaveBeenCalledWith(element);
       expect(domStrategy.insertElement).toHaveBeenCalledWith(element);

npm/ng-packs/packages/core/src/lib/tests/dom-insertion.service.spec.ts

@@ -9,7 +9,7 @@ describe('DomInsertionService', () => {
 
   beforeEach(() => (spectator = createService()));
 
-  afterEach(() => styleElements.forEach(element => element.remove()));
+  afterEach(() => (document.head.innerHTML = ''));
 
   describe('#insertContent', () => {
     it('should be able to insert given content', () => {
@@ -19,6 +19,11 @@ describe('DomInsertionService', () => {
       expect(styleElements[0].textContent).toBe('.test {}');
     });
 
+    it('should set a hash for the inserted content', () => {
+      spectator.service.insertContent(CONTENT_STRATEGY.AppendStyleToHead('.test {}'));
+      expect(spectator.service.inserted.has(1437348290)).toBe(true);
+    });
+
     it('should insert only once', () => {
       expect(spectator.service.inserted.has(1437348290)).toBe(false);
 
@@ -37,9 +42,25 @@ describe('DomInsertionService', () => {
       expect(spectator.service.inserted.has(1437348290)).toBe(true);
     });
 
-    it('should be able to insert given content', () => {
-      spectator.service.insertContent(CONTENT_STRATEGY.AppendStyleToHead('.test {}'));
+    it('should return inserted element', () => {
+      const element = spectator.service.insertContent(
+        CONTENT_STRATEGY.AppendStyleToHead('.test {}'),
+      );
+      expect(element.tagName).toBe('STYLE');
+    });
+  });
+
+  describe('#removeContent', () => {
+    it('should remove inserted element and the hash for the content', () => {
+      expect(document.head.querySelector('style')).toBeNull();
+      const element = spectator.service.insertContent(
+        CONTENT_STRATEGY.AppendStyleToHead('.test {}'),
+      );
       expect(spectator.service.inserted.has(1437348290)).toBe(true);
+
+      spectator.service.removeContent(element);
+      expect(spectator.service.inserted.has(1437348290)).toBe(false);
+      expect(document.head.querySelector('style')).toBeNull();
     });
   });
 });

npm/ng-packs/packages/core/src/lib/tests/initial-utils.spec.ts

@@ -1,7 +1,6 @@
 import { Component, Injector } from '@angular/core';
 import { createComponentFactory, Spectator } from '@ngneat/spectator/jest';
 import { Store } from '@ngxs/store';
-import { OAuthService } from 'angular-oauth2-oidc';
 import { of } from 'rxjs';
 import { GetAppConfiguration } from '../actions';
 import { getInitialData, localeInitializer } from '../utils';
@@ -29,6 +28,7 @@ describe('InitialUtils', () => {
       const dispatchSpy = jest.spyOn(store, 'dispatch');
 
       injectorSpy.mockReturnValueOnce(store);
+      injectorSpy.mockReturnValueOnce({ skipGetAppConfiguration: false });
       injectorSpy.mockReturnValueOnce({ hasValidAccessToken: () => false });
       dispatchSpy.mockReturnValue(of('test'));
 
@@ -47,6 +47,7 @@ describe('InitialUtils', () => {
       const logOutFn = jest.fn();
 
       injectorSpy.mockReturnValueOnce(store);
+      injectorSpy.mockReturnValueOnce({ skipGetAppConfiguration: false });
       injectorSpy.mockReturnValueOnce({ hasValidAccessToken: () => true, logOut: logOutFn });
       dispatchSpy.mockReturnValue(of({ currentUser: { id: null } }));
 

npm/ng-packs/packages/core/src/lib/tokens/common.token.ts

@@ -1,18 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { Config } from '../models';
-
-export function environmentFactory(environment: Config.Environment) {
-  return {
-    ...environment,
-  };
-}
-
-export function configFactory(config: Config.Requirements) {
-  return {
-    ...config,
-  };
-}
-
-export const ENVIRONMENT = new InjectionToken('ENVIRONMENT');
-
-export const CONFIG = new InjectionToken('CONFIG');

npm/ng-packs/packages/core/src/lib/tokens/index.ts

@@ -1 +1 @@
-export * from './common.token';
+export * from './options.token';

npm/ng-packs/packages/core/src/lib/tokens/options.token.ts

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+import { ABP } from '../models/common';
+
+export const CORE_OPTIONS = new InjectionToken<ABP.Root>('CORE_OPTIONS');

npm/ng-packs/packages/core/src/lib/utils/initial-utils.ts

@@ -1,16 +1,20 @@
 import { registerLocaleData } from '@angular/common';
 import { Injector } from '@angular/core';
 import { Store } from '@ngxs/store';
+import { OAuthService } from 'angular-oauth2-oidc';
+import { tap } from 'rxjs/operators';
 import { GetAppConfiguration } from '../actions/config.actions';
 import differentLocales from '../constants/different-locales';
-import { ApplicationConfiguration } from '../models/application-configuration';
-import { tap } from 'rxjs/operators';
+import { ABP } from '../models/common';
 import { ConfigState } from '../states/config.state';
-import { OAuthService } from 'angular-oauth2-oidc';
+import { CORE_OPTIONS } from '../tokens/options.token';
 
 export function getInitialData(injector: Injector) {
   const fn = () => {
     const store: Store = injector.get(Store);
+    const { skipGetAppConfiguration } = injector.get(CORE_OPTIONS) as ABP.Root;
+
+    if (skipGetAppConfiguration) return;
 
     return store
       .dispatch(new GetAppConfiguration())

npm/ng-packs/packages/theme-basic/src/lib/components/application-layout/application-layout.component.html

@@ -155,9 +155,6 @@
   <router-outlet #outlet="outlet"></router-outlet>
 </div>
 
-<abp-confirmation></abp-confirmation>
-<abp-toast-container right="30px" bottom="30px"></abp-toast-container>
-
 <ng-template #appName>
   {{ appInfo.name }}
 </ng-template>

npm/ng-packs/packages/theme-shared/src/lib/services/confirmation.service.ts

@@ -1,14 +1,29 @@
-import { Injectable } from '@angular/core';
+import { Injectable, ComponentRef } from '@angular/core';
 import { Confirmation } from '../models/confirmation';
 import { fromEvent, Observable, Subject, ReplaySubject } from 'rxjs';
 import { takeUntil, debounceTime, filter } from 'rxjs/operators';
-import { Config } from '@abp/ng.core';
+import { Config, ContentProjectionService, PROJECTION_STRATEGY } from '@abp/ng.core';
+import { ConfirmationComponent } from '../components/confirmation/confirmation.component';
 
 @Injectable({ providedIn: 'root' })
 export class ConfirmationService {
   status$: Subject<Confirmation.Status>;
   confirmation$ = new ReplaySubject<Confirmation.DialogData>(1);
 
+  private containerComponentRef: ComponentRef<ConfirmationComponent>;
+
+  constructor(private contentProjectionService: ContentProjectionService) {}
+
+  private setContainer() {
+    setTimeout(() => {
+      this.containerComponentRef = this.contentProjectionService.projectContent(
+        PROJECTION_STRATEGY.AppendComponentToBody(ConfirmationComponent),
+      );
+
+      this.containerComponentRef.changeDetectorRef.detectChanges();
+    }, 0);
+  }
+
   info(
     message: Config.LocalizationParam,
     title: Config.LocalizationParam,
@@ -47,6 +62,8 @@ export class ConfirmationService {
     severity?: Confirmation.Severity,
     options?: Partial<Confirmation.Options>,
   ): Observable<Confirmation.Status> {
+    if (!this.containerComponentRef) this.setContainer();
+
     this.confirmation$.next({
       message,
       title,

npm/ng-packs/packages/theme-shared/src/lib/services/toaster.service.ts

@@ -1,8 +1,9 @@
-import { Injectable } from '@angular/core';
+import { Injectable, ComponentRef } from '@angular/core';
 import { Toaster } from '../models';
 import { ReplaySubject } from 'rxjs';
-import { Config } from '@abp/ng.core';
+import { Config, PROJECTION_STRATEGY, ContentProjectionService } from '@abp/ng.core';
 import snq from 'snq';
+import { ToastContainerComponent } from '../components/toast-container/toast-container.component';
 
 @Injectable({
   providedIn: 'root',
@@ -14,6 +15,18 @@ export class ToasterService {
 
   private toasts = [] as Toaster.Toast[];
 
+  private containerComponentRef: ComponentRef<ToastContainerComponent>;
+
+  constructor(private contentProjectionService: ContentProjectionService) {}
+
+  private setContainer() {
+    this.containerComponentRef = this.contentProjectionService.projectContent(
+      PROJECTION_STRATEGY.AppendComponentToBody(ToastContainerComponent),
+    );
+
+    this.containerComponentRef.changeDetectorRef.detectChanges();
+  }
+
   /**
    * Creates an info toast with given parameters.
    * @param message Content of the toast
@@ -84,6 +97,8 @@ export class ToasterService {
     severity: Toaster.Severity = 'neutral',
     options = {} as Partial<Toaster.ToastOptions>,
   ) {
+    if (!this.containerComponentRef) this.setContainer();
+
     const id = ++this.lastId;
     this.toasts.push({
       message,

npm/ng-packs/packages/theme-shared/src/lib/tests/confirmation.service.spec.ts

@@ -31,7 +31,7 @@ describe('ConfirmationService', () => {
     service = spectator.get(ConfirmationService);
   });
 
-  test('should display a confirmation popup', () => {
+  test.skip('should display a confirmation popup', () => {
     service.info('test', 'title');
 
     spectator.detectChanges();
@@ -40,7 +40,7 @@ describe('ConfirmationService', () => {
     expect(spectator.query('div.confirmation .message')).toHaveText('test');
   });
 
-  test('should close with ESC key', done => {
+  test.skip('should close with ESC key', done => {
     service.info('test', 'title').subscribe(() => {
       setTimeout(() => {
         spectator.detectComponentChanges();
@@ -54,7 +54,7 @@ describe('ConfirmationService', () => {
     spectator.dispatchKeyboardEvent('div.confirmation', 'keyup', 'Escape');
   });
 
-  test('should close when click cancel button', done => {
+  test.skip('should close when click cancel button', done => {
     service.info('test', 'title', { yesText: 'Sure', cancelText: 'Exit' }).subscribe(() => {
       spectator.detectComponentChanges();
       setTimeout(() => {

npm/ng-packs/packages/theme-shared/src/lib/tests/error.handler.spec.ts

@@ -40,7 +40,7 @@ describe('ErrorHandler', () => {
     if (abpError) document.body.removeChild(abpError);
   });
 
-  it('should display the error component when server error occurs', () => {
+  test.skip('should display the error component when server error occurs', () => {
     store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 500 })));
     expect(document.querySelector('.error-template')).toHaveText(
       DEFAULT_ERROR_MESSAGES.defaultError500.title,
@@ -50,7 +50,7 @@ describe('ErrorHandler', () => {
     );
   });
 
-  it('should display the error component when authorize error occurs', () => {
+  test.skip('should display the error component when authorize error occurs', () => {
     store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 403 })));
     expect(document.querySelector('.error-template')).toHaveText(
       DEFAULT_ERROR_MESSAGES.defaultError403.title,
@@ -60,7 +60,7 @@ describe('ErrorHandler', () => {
     );
   });
 
-  it('should display the error component when unknown error occurs', () => {
+  test.skip('should display the error component when unknown error occurs', () => {
     store.dispatch(
       new RestOccurError(new HttpErrorResponse({ status: 0, statusText: 'Unknown Error' })),
     );
@@ -69,7 +69,7 @@ describe('ErrorHandler', () => {
     );
   });
 
-  it('should display the confirmation when not found error occurs', () => {
+  test.skip('should display the confirmation when not found error occurs', () => {
     store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 404 })));
     spectator.detectChanges();
     expect(spectator.query('.confirmation .title')).toHaveText(
@@ -80,7 +80,7 @@ describe('ErrorHandler', () => {
     );
   });
 
-  it('should display the confirmation when default error occurs', () => {
+  test.skip('should display the confirmation when default error occurs', () => {
     store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 412 })));
     spectator.detectChanges();
     expect(spectator.query('.confirmation .title')).toHaveText(
@@ -91,7 +91,7 @@ describe('ErrorHandler', () => {
     );
   });
 
-  it('should display the confirmation when authenticated error occurs', async () => {
+  test.skip('should display the confirmation when authenticated error occurs', async () => {
     store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 401 })));
     spectator.detectChanges();
 
@@ -100,7 +100,7 @@ describe('ErrorHandler', () => {
     expect(spectator.get(Location).path()).toBe('/account/login');
   });
 
-  it('should display the confirmation when authenticated error occurs with _AbpErrorFormat header', async () => {
+  test.skip('should display the confirmation when authenticated error occurs with _AbpErrorFormat header', async () => {
     let headers: HttpHeaders = new HttpHeaders();
     headers = headers.append('_AbpErrorFormat', '_AbpErrorFormat');
 
@@ -112,7 +112,7 @@ describe('ErrorHandler', () => {
     expect(spectator.get(Location).path()).toBe('/account/login');
   });
 
-  it('should display the confirmation when error occurs with _AbpErrorFormat header', () => {
+  test.skip('should display the confirmation when error occurs with _AbpErrorFormat header', () => {
     let headers: HttpHeaders = new HttpHeaders();
     headers = headers.append('_AbpErrorFormat', '_AbpErrorFormat');
 
@@ -180,34 +180,34 @@ describe('ErrorHandler with custom error component', () => {
   });
 
   describe('Custom error component', () => {
-    it('should create when occur 401', () => {
+    test.skip('should create when occur 401', () => {
       store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 401 })));
       expect(document.querySelector('abp-dummy-error')).toBeTruthy();
       expect(document.querySelector('p')).toHaveExactText('401');
     });
 
-    it('should create when occur 403', () => {
+    test.skip('should create when occur 403', () => {
       store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 403 })));
       expect(document.querySelector('p')).toHaveExactText('403');
     });
 
-    it('should create when occur 404', () => {
+    test.skip('should create when occur 404', () => {
       store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 404 })));
       expect(document.querySelector('p')).toHaveExactText('404');
     });
 
-    it('should create when dispatched the RouterError', () => {
+    test.skip('should create when dispatched the RouterError', () => {
       store.dispatch(new RouterError(null, null, new NavigationError(1, 'test', 'Cannot match')));
       expect(document.querySelector('p')).toHaveExactText('404');
       store.dispatch(new RouterDataResolved(null, new ResolveEnd(1, 'test', 'test', null)));
     });
 
-    it('should create when occur 500', () => {
+    test.skip('should create when occur 500', () => {
       store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 500 })));
       expect(document.querySelector('p')).toHaveExactText('500');
     });
 
-    it('should be destroyed when click the close button', () => {
+    test.skip('should be destroyed when click the close button', () => {
       store.dispatch(new RestOccurError(new HttpErrorResponse({ status: 500 })));
       document.querySelector<HTMLButtonElement>('#close-dummy').click();
       spectator.detectChanges();

npm/ng-packs/packages/theme-shared/src/lib/tests/toaster.service.spec.ts

@@ -31,7 +31,7 @@ describe('ToasterService', () => {
     service = spectator.get(ToasterService);
   });
 
-  test('should display an error toast', () => {
+  test.skip('should display an error toast', () => {
     service.error('test', 'title');
 
     spectator.detectChanges();
@@ -42,25 +42,25 @@ describe('ToasterService', () => {
     expect(spectator.query('p.toast-message')).toHaveText('test');
   });
 
-  test('should display a warning toast', () => {
+  test.skip('should display a warning toast', () => {
     service.warn('test', 'title');
     spectator.detectChanges();
     expect(spectator.query('.toast-icon i')).toHaveClass('fa-exclamation-triangle');
   });
 
-  test('should display a success toast', () => {
+  test.skip('should display a success toast', () => {
     service.success('test', 'title');
     spectator.detectChanges();
     expect(spectator.query('.toast-icon i')).toHaveClass('fa-check-circle');
   });
 
-  test('should display an info toast', () => {
+  test.skip('should display an info toast', () => {
     service.info('test', 'title');
     spectator.detectChanges();
     expect(spectator.query('.toast-icon i')).toHaveClass('fa-info-circle');
   });
 
-  test('should display multiple toasts', () => {
+  test.skip('should display multiple toasts', () => {
     service.info('detail1', 'summary1');
     service.info('detail2', 'summary2');
 
@@ -75,7 +75,7 @@ describe('ToasterService', () => {
     ]);
   });
 
-  test('should remove the opened toasts', () => {
+  test.skip('should remove the opened toasts', () => {
     service.info('test', 'title');
     spectator.detectChanges();
     expect(spectator.query('div.toast')).toBeTruthy();

npm/ng-packs/packages/theme-shared/src/lib/theme-shared.module.ts

@@ -83,7 +83,13 @@ export function appendScript(injector: Injector) {
     TableSortDirective,
   ],
   providers: [DatePipe],
-  entryComponents: [HttpErrorWrapperComponent, LoadingComponent, ModalContainerComponent],
+  entryComponents: [
+    HttpErrorWrapperComponent,
+    LoadingComponent,
+    ModalContainerComponent,
+    ToastContainerComponent,
+    ConfirmationComponent,
+  ],
 })
 export class ThemeSharedModule {
   constructor(private errorHandler: ErrorHandler) {}

npm/ng-packs/scripts/install-new-dependencies.ts

@@ -13,15 +13,11 @@ const updateAndInstall = async () => {
       `../packages/${project}/package.json`,
     );
 
-    const isPackageExistOnNPM = !(
-      execa.sync('npm', ['search', name]).stdout.indexOf('No matches found for') > -1
-    );
-
     packageJson.devDependencies = {
       ...packageJson.devDependencies,
       ...dependencies,
       ...peerDependencies,
-      ...(isPackageExistOnNPM && { [name]: `~${version}` }),
+      [name]: `^${version}`,
     };
 
     packageJson.devDependencies = Object.keys(packageJson.devDependencies)
@@ -29,6 +25,15 @@ const updateAndInstall = async () => {
       .reduce((acc, key) => ({ ...acc, [key]: packageJson.devDependencies[key] }), {});
   });
 
+  console.warn('Searching the packages on NPM to check if it is exist. It takes a while.');
+  Object.keys(packageJson.devDependencies).forEach(pkg => {
+    const isPackageExistOnNPM = !(
+      execa.sync('npm', ['search', pkg]).stdout.indexOf('No matches found for') > -1
+    );
+
+    if (!isPackageExistOnNPM) delete packageJson.devDependencies[pkg];
+  });
+
   await fse.writeJSON('../package.json', packageJson, { spaces: 2 });
 
   try {

npm/packs/core/package.json

@@ -4,5 +4,8 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@abp/utils": "^2.5.0"
+  },
   "gitHead": "a9a36b8a4681df04377497addf94b15e6c521664"
 }

npm/packs/datatables.net/package.json

@@ -5,7 +5,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@abp/core": "^2.5.0",
+    "@abp/jquery": "^2.5.0",
     "datatables.net": "^1.10.20"
   },
   "gitHead": "a9a36b8a4681df04377497addf94b15e6c521664"

npm/packs/select2/abp.resourcemapping.js

@@ -3,6 +3,7 @@
         "@node_modules/select2/dist/css/select2.min.css": "@libs/select2/css/",
         "@node_modules/select2/dist/js/select2.min.js": "@libs/select2/js/",
         "@node_modules/select2/dist/js/select2.full.min.js": "@libs/select2/js/",
-        "@node_modules/select2/dist/js/i18n/*.js": "@libs/select2/js/i18n/"
+        "@node_modules/select2/dist/js/i18n/*.js": "@libs/select2/js/i18n/",
+        "@node_modules/@abp/select2/src/*.*": "@libs/select2/js/"
     }
 }

npm/packs/select2/src/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

samples/MicroserviceDemo/applications/AuthServer.Host/wwwroot/libs/abp/utils/abp-utils.umd.js

@@ -0,0 +1,600 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('just-compare')) :
+    typeof define === 'function' && define.amd ? define('@abp/utils', ['exports', 'just-compare'], factory) :
+    (global = global || self, factory((global.abp = global.abp || {}, global.abp.utils = global.abp.utils || {}, global.abp.utils.common = {}), global.compare));
+}(this, (function (exports, compare) { 'use strict';
+
+    compare = compare && Object.prototype.hasOwnProperty.call(compare, 'default') ? compare['default'] : compare;
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __exportStar(m, exports) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    };
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+        return cooked;
+    };
+
+    function __importStar(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+        result.default = mod;
+        return result;
+    }
+
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    function __classPrivateFieldGet(receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    }
+
+    function __classPrivateFieldSet(receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
+    }
+
+    /* tslint:disable:no-non-null-assertion */
+    var ListNode = /** @class */ (function () {
+        function ListNode(value) {
+            this.value = value;
+        }
+        return ListNode;
+    }());
+    var LinkedList = /** @class */ (function () {
+        function LinkedList() {
+            this.size = 0;
+        }
+        Object.defineProperty(LinkedList.prototype, "head", {
+            get: function () {
+                return this.first;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "tail", {
+            get: function () {
+                return this.last;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "length", {
+            get: function () {
+                return this.size;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        LinkedList.prototype.attach = function (value, previousNode, nextNode) {
+            if (!previousNode)
+                return this.addHead(value);
+            if (!nextNode)
+                return this.addTail(value);
+            var node = new ListNode(value);
+            node.previous = previousNode;
+            previousNode.next = node;
+            node.next = nextNode;
+            nextNode.previous = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.attachMany = function (values, previousNode, nextNode) {
+            if (!values.length)
+                return [];
+            if (!previousNode)
+                return this.addManyHead(values);
+            if (!nextNode)
+                return this.addManyTail(values);
+            var list = new LinkedList();
+            list.addManyTail(values);
+            list.first.previous = previousNode;
+            previousNode.next = list.first;
+            list.last.next = nextNode;
+            nextNode.previous = list.last;
+            this.size += values.length;
+            return list.toNodeArray();
+        };
+        LinkedList.prototype.detach = function (node) {
+            if (!node.previous)
+                return this.dropHead();
+            if (!node.next)
+                return this.dropTail();
+            node.previous.next = node.next;
+            node.next.previous = node.previous;
+            this.size--;
+            return node;
+        };
+        LinkedList.prototype.add = function (value) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addAfter).call.apply(_a, __spread([_this, value], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addBefore).call.apply(_a, __spread([_this, value], params));
+                },
+                byIndex: function (position) { return _this.addByIndex(value, position); },
+                head: function () { return _this.addHead(value); },
+                tail: function () { return _this.addTail(value); },
+            };
+        };
+        LinkedList.prototype.addMany = function (values) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyAfter).call.apply(_a, __spread([_this, values], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyBefore).call.apply(_a, __spread([_this, values], params));
+                },
+                byIndex: function (position) { return _this.addManyByIndex(values, position); },
+                head: function () { return _this.addManyHead(values); },
+                tail: function () { return _this.addManyTail(values); },
+            };
+        };
+        LinkedList.prototype.addAfter = function (value, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attach(value, previous, previous.next) : this.addTail(value);
+        };
+        LinkedList.prototype.addBefore = function (value, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attach(value, next.previous, next) : this.addHead(value);
+        };
+        LinkedList.prototype.addByIndex = function (value, position) {
+            if (position < 0)
+                position += this.size;
+            else if (position >= this.size)
+                return this.addTail(value);
+            if (position <= 0)
+                return this.addHead(value);
+            var next = this.get(position);
+            return this.attach(value, next.previous, next);
+        };
+        LinkedList.prototype.addHead = function (value) {
+            var node = new ListNode(value);
+            node.next = this.first;
+            if (this.first)
+                this.first.previous = node;
+            else
+                this.last = node;
+            this.first = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addTail = function (value) {
+            var node = new ListNode(value);
+            if (this.first) {
+                node.previous = this.last;
+                this.last.next = node;
+                this.last = node;
+            }
+            else {
+                this.first = node;
+                this.last = node;
+            }
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addManyAfter = function (values, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attachMany(values, previous, previous.next) : this.addManyTail(values);
+        };
+        LinkedList.prototype.addManyBefore = function (values, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attachMany(values, next.previous, next) : this.addManyHead(values);
+        };
+        LinkedList.prototype.addManyByIndex = function (values, position) {
+            if (position < 0)
+                position += this.size;
+            if (position <= 0)
+                return this.addManyHead(values);
+            if (position >= this.size)
+                return this.addManyTail(values);
+            var next = this.get(position);
+            return this.attachMany(values, next.previous, next);
+        };
+        LinkedList.prototype.addManyHead = function (values) {
+            var _this = this;
+            return values.reduceRight(function (nodes, value) {
+                nodes.unshift(_this.addHead(value));
+                return nodes;
+            }, []);
+        };
+        LinkedList.prototype.addManyTail = function (values) {
+            var _this = this;
+            return values.map(function (value) { return _this.addTail(value); });
+        };
+        LinkedList.prototype.drop = function () {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropByIndex(position); },
+                byValue: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValue.apply(_this, params);
+                },
+                byValueAll: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValueAll.apply(_this, params);
+                },
+                head: function () { return _this.dropHead(); },
+                tail: function () { return _this.dropTail(); },
+            };
+        };
+        LinkedList.prototype.dropMany = function (count) {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropManyByIndex(count, position); },
+                head: function () { return _this.dropManyHead(count); },
+                tail: function () { return _this.dropManyTail(count); },
+            };
+        };
+        LinkedList.prototype.dropByIndex = function (position) {
+            if (position < 0)
+                position += this.size;
+            var current = this.get(position);
+            return current ? this.detach(current) : undefined;
+        };
+        LinkedList.prototype.dropByValue = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var position = this.findIndex(function (node) { return compareFn(node.value, value); });
+            return position < 0 ? undefined : this.dropByIndex(position);
+        };
+        LinkedList.prototype.dropByValueAll = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var dropped = [];
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (compareFn(current.value, value)) {
+                    dropped.push(this.dropByIndex(position - dropped.length));
+                }
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropHead = function () {
+            var head = this.first;
+            if (head) {
+                this.first = head.next;
+                if (this.first)
+                    this.first.previous = undefined;
+                else
+                    this.last = undefined;
+                this.size--;
+                return head;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropTail = function () {
+            var tail = this.last;
+            if (tail) {
+                this.last = tail.previous;
+                if (this.last)
+                    this.last.next = undefined;
+                else
+                    this.first = undefined;
+                this.size--;
+                return tail;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropManyByIndex = function (count, position) {
+            if (count <= 0)
+                return [];
+            if (position < 0)
+                position = Math.max(position + this.size, 0);
+            else if (position >= this.size)
+                return [];
+            count = Math.min(count, this.size - position);
+            var dropped = [];
+            while (count--) {
+                var current = this.get(position);
+                dropped.push(this.detach(current));
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropManyHead = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.unshift(this.dropHead());
+            return dropped;
+        };
+        LinkedList.prototype.dropManyTail = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.push(this.dropTail());
+            return dropped;
+        };
+        LinkedList.prototype.find = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return current;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.findIndex = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return position;
+            }
+            return -1;
+        };
+        LinkedList.prototype.forEach = function (callback) {
+            for (var node = this.first, position = 0; node; position++, node = node.next) {
+                callback(node, position, this);
+            }
+        };
+        LinkedList.prototype.get = function (position) {
+            return this.find(function (_, index) { return position === index; });
+        };
+        LinkedList.prototype.indexOf = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            return this.findIndex(function (node) { return compareFn(node.value, value); });
+        };
+        LinkedList.prototype.toArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node.value); });
+            return array;
+        };
+        LinkedList.prototype.toNodeArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node); });
+            return array;
+        };
+        LinkedList.prototype.toString = function (mapperFn) {
+            if (mapperFn === void 0) { mapperFn = JSON.stringify; }
+            return this.toArray()
+                .map(function (value) { return mapperFn(value); })
+                .join(' <-> ');
+        };
+        // Cannot use Generator type because of ng-packagr
+        LinkedList.prototype[Symbol.iterator] = function () {
+            var node, position;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.first, position = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!node) return [3 /*break*/, 4];
+                        return [4 /*yield*/, node.value];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        position++, node = node.next;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        };
+        return LinkedList;
+    }());
+
+    exports.LinkedList = LinkedList;
+    exports.ListNode = ListNode;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=abp-utils.umd.js.map

samples/MicroserviceDemo/applications/AuthServer.Host/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

samples/MicroserviceDemo/applications/BackendAdminApp.Host/wwwroot/libs/abp/utils/abp-utils.umd.js

@@ -0,0 +1,600 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('just-compare')) :
+    typeof define === 'function' && define.amd ? define('@abp/utils', ['exports', 'just-compare'], factory) :
+    (global = global || self, factory((global.abp = global.abp || {}, global.abp.utils = global.abp.utils || {}, global.abp.utils.common = {}), global.compare));
+}(this, (function (exports, compare) { 'use strict';
+
+    compare = compare && Object.prototype.hasOwnProperty.call(compare, 'default') ? compare['default'] : compare;
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __exportStar(m, exports) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    };
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+        return cooked;
+    };
+
+    function __importStar(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+        result.default = mod;
+        return result;
+    }
+
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    function __classPrivateFieldGet(receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    }
+
+    function __classPrivateFieldSet(receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
+    }
+
+    /* tslint:disable:no-non-null-assertion */
+    var ListNode = /** @class */ (function () {
+        function ListNode(value) {
+            this.value = value;
+        }
+        return ListNode;
+    }());
+    var LinkedList = /** @class */ (function () {
+        function LinkedList() {
+            this.size = 0;
+        }
+        Object.defineProperty(LinkedList.prototype, "head", {
+            get: function () {
+                return this.first;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "tail", {
+            get: function () {
+                return this.last;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "length", {
+            get: function () {
+                return this.size;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        LinkedList.prototype.attach = function (value, previousNode, nextNode) {
+            if (!previousNode)
+                return this.addHead(value);
+            if (!nextNode)
+                return this.addTail(value);
+            var node = new ListNode(value);
+            node.previous = previousNode;
+            previousNode.next = node;
+            node.next = nextNode;
+            nextNode.previous = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.attachMany = function (values, previousNode, nextNode) {
+            if (!values.length)
+                return [];
+            if (!previousNode)
+                return this.addManyHead(values);
+            if (!nextNode)
+                return this.addManyTail(values);
+            var list = new LinkedList();
+            list.addManyTail(values);
+            list.first.previous = previousNode;
+            previousNode.next = list.first;
+            list.last.next = nextNode;
+            nextNode.previous = list.last;
+            this.size += values.length;
+            return list.toNodeArray();
+        };
+        LinkedList.prototype.detach = function (node) {
+            if (!node.previous)
+                return this.dropHead();
+            if (!node.next)
+                return this.dropTail();
+            node.previous.next = node.next;
+            node.next.previous = node.previous;
+            this.size--;
+            return node;
+        };
+        LinkedList.prototype.add = function (value) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addAfter).call.apply(_a, __spread([_this, value], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addBefore).call.apply(_a, __spread([_this, value], params));
+                },
+                byIndex: function (position) { return _this.addByIndex(value, position); },
+                head: function () { return _this.addHead(value); },
+                tail: function () { return _this.addTail(value); },
+            };
+        };
+        LinkedList.prototype.addMany = function (values) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyAfter).call.apply(_a, __spread([_this, values], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyBefore).call.apply(_a, __spread([_this, values], params));
+                },
+                byIndex: function (position) { return _this.addManyByIndex(values, position); },
+                head: function () { return _this.addManyHead(values); },
+                tail: function () { return _this.addManyTail(values); },
+            };
+        };
+        LinkedList.prototype.addAfter = function (value, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attach(value, previous, previous.next) : this.addTail(value);
+        };
+        LinkedList.prototype.addBefore = function (value, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attach(value, next.previous, next) : this.addHead(value);
+        };
+        LinkedList.prototype.addByIndex = function (value, position) {
+            if (position < 0)
+                position += this.size;
+            else if (position >= this.size)
+                return this.addTail(value);
+            if (position <= 0)
+                return this.addHead(value);
+            var next = this.get(position);
+            return this.attach(value, next.previous, next);
+        };
+        LinkedList.prototype.addHead = function (value) {
+            var node = new ListNode(value);
+            node.next = this.first;
+            if (this.first)
+                this.first.previous = node;
+            else
+                this.last = node;
+            this.first = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addTail = function (value) {
+            var node = new ListNode(value);
+            if (this.first) {
+                node.previous = this.last;
+                this.last.next = node;
+                this.last = node;
+            }
+            else {
+                this.first = node;
+                this.last = node;
+            }
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addManyAfter = function (values, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attachMany(values, previous, previous.next) : this.addManyTail(values);
+        };
+        LinkedList.prototype.addManyBefore = function (values, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attachMany(values, next.previous, next) : this.addManyHead(values);
+        };
+        LinkedList.prototype.addManyByIndex = function (values, position) {
+            if (position < 0)
+                position += this.size;
+            if (position <= 0)
+                return this.addManyHead(values);
+            if (position >= this.size)
+                return this.addManyTail(values);
+            var next = this.get(position);
+            return this.attachMany(values, next.previous, next);
+        };
+        LinkedList.prototype.addManyHead = function (values) {
+            var _this = this;
+            return values.reduceRight(function (nodes, value) {
+                nodes.unshift(_this.addHead(value));
+                return nodes;
+            }, []);
+        };
+        LinkedList.prototype.addManyTail = function (values) {
+            var _this = this;
+            return values.map(function (value) { return _this.addTail(value); });
+        };
+        LinkedList.prototype.drop = function () {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropByIndex(position); },
+                byValue: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValue.apply(_this, params);
+                },
+                byValueAll: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValueAll.apply(_this, params);
+                },
+                head: function () { return _this.dropHead(); },
+                tail: function () { return _this.dropTail(); },
+            };
+        };
+        LinkedList.prototype.dropMany = function (count) {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropManyByIndex(count, position); },
+                head: function () { return _this.dropManyHead(count); },
+                tail: function () { return _this.dropManyTail(count); },
+            };
+        };
+        LinkedList.prototype.dropByIndex = function (position) {
+            if (position < 0)
+                position += this.size;
+            var current = this.get(position);
+            return current ? this.detach(current) : undefined;
+        };
+        LinkedList.prototype.dropByValue = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var position = this.findIndex(function (node) { return compareFn(node.value, value); });
+            return position < 0 ? undefined : this.dropByIndex(position);
+        };
+        LinkedList.prototype.dropByValueAll = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var dropped = [];
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (compareFn(current.value, value)) {
+                    dropped.push(this.dropByIndex(position - dropped.length));
+                }
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropHead = function () {
+            var head = this.first;
+            if (head) {
+                this.first = head.next;
+                if (this.first)
+                    this.first.previous = undefined;
+                else
+                    this.last = undefined;
+                this.size--;
+                return head;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropTail = function () {
+            var tail = this.last;
+            if (tail) {
+                this.last = tail.previous;
+                if (this.last)
+                    this.last.next = undefined;
+                else
+                    this.first = undefined;
+                this.size--;
+                return tail;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropManyByIndex = function (count, position) {
+            if (count <= 0)
+                return [];
+            if (position < 0)
+                position = Math.max(position + this.size, 0);
+            else if (position >= this.size)
+                return [];
+            count = Math.min(count, this.size - position);
+            var dropped = [];
+            while (count--) {
+                var current = this.get(position);
+                dropped.push(this.detach(current));
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropManyHead = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.unshift(this.dropHead());
+            return dropped;
+        };
+        LinkedList.prototype.dropManyTail = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.push(this.dropTail());
+            return dropped;
+        };
+        LinkedList.prototype.find = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return current;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.findIndex = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return position;
+            }
+            return -1;
+        };
+        LinkedList.prototype.forEach = function (callback) {
+            for (var node = this.first, position = 0; node; position++, node = node.next) {
+                callback(node, position, this);
+            }
+        };
+        LinkedList.prototype.get = function (position) {
+            return this.find(function (_, index) { return position === index; });
+        };
+        LinkedList.prototype.indexOf = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            return this.findIndex(function (node) { return compareFn(node.value, value); });
+        };
+        LinkedList.prototype.toArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node.value); });
+            return array;
+        };
+        LinkedList.prototype.toNodeArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node); });
+            return array;
+        };
+        LinkedList.prototype.toString = function (mapperFn) {
+            if (mapperFn === void 0) { mapperFn = JSON.stringify; }
+            return this.toArray()
+                .map(function (value) { return mapperFn(value); })
+                .join(' <-> ');
+        };
+        // Cannot use Generator type because of ng-packagr
+        LinkedList.prototype[Symbol.iterator] = function () {
+            var node, position;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.first, position = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!node) return [3 /*break*/, 4];
+                        return [4 /*yield*/, node.value];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        position++, node = node.next;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        };
+        return LinkedList;
+    }());
+
+    exports.LinkedList = LinkedList;
+    exports.ListNode = ListNode;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=abp-utils.umd.js.map

samples/MicroserviceDemo/applications/BackendAdminApp.Host/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

samples/MicroserviceDemo/applications/PublicWebSite.Host/wwwroot/libs/abp/utils/abp-utils.umd.js

@@ -0,0 +1,600 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('just-compare')) :
+    typeof define === 'function' && define.amd ? define('@abp/utils', ['exports', 'just-compare'], factory) :
+    (global = global || self, factory((global.abp = global.abp || {}, global.abp.utils = global.abp.utils || {}, global.abp.utils.common = {}), global.compare));
+}(this, (function (exports, compare) { 'use strict';
+
+    compare = compare && Object.prototype.hasOwnProperty.call(compare, 'default') ? compare['default'] : compare;
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __exportStar(m, exports) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    };
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+        return cooked;
+    };
+
+    function __importStar(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+        result.default = mod;
+        return result;
+    }
+
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    function __classPrivateFieldGet(receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    }
+
+    function __classPrivateFieldSet(receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
+    }
+
+    /* tslint:disable:no-non-null-assertion */
+    var ListNode = /** @class */ (function () {
+        function ListNode(value) {
+            this.value = value;
+        }
+        return ListNode;
+    }());
+    var LinkedList = /** @class */ (function () {
+        function LinkedList() {
+            this.size = 0;
+        }
+        Object.defineProperty(LinkedList.prototype, "head", {
+            get: function () {
+                return this.first;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "tail", {
+            get: function () {
+                return this.last;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "length", {
+            get: function () {
+                return this.size;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        LinkedList.prototype.attach = function (value, previousNode, nextNode) {
+            if (!previousNode)
+                return this.addHead(value);
+            if (!nextNode)
+                return this.addTail(value);
+            var node = new ListNode(value);
+            node.previous = previousNode;
+            previousNode.next = node;
+            node.next = nextNode;
+            nextNode.previous = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.attachMany = function (values, previousNode, nextNode) {
+            if (!values.length)
+                return [];
+            if (!previousNode)
+                return this.addManyHead(values);
+            if (!nextNode)
+                return this.addManyTail(values);
+            var list = new LinkedList();
+            list.addManyTail(values);
+            list.first.previous = previousNode;
+            previousNode.next = list.first;
+            list.last.next = nextNode;
+            nextNode.previous = list.last;
+            this.size += values.length;
+            return list.toNodeArray();
+        };
+        LinkedList.prototype.detach = function (node) {
+            if (!node.previous)
+                return this.dropHead();
+            if (!node.next)
+                return this.dropTail();
+            node.previous.next = node.next;
+            node.next.previous = node.previous;
+            this.size--;
+            return node;
+        };
+        LinkedList.prototype.add = function (value) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addAfter).call.apply(_a, __spread([_this, value], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addBefore).call.apply(_a, __spread([_this, value], params));
+                },
+                byIndex: function (position) { return _this.addByIndex(value, position); },
+                head: function () { return _this.addHead(value); },
+                tail: function () { return _this.addTail(value); },
+            };
+        };
+        LinkedList.prototype.addMany = function (values) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyAfter).call.apply(_a, __spread([_this, values], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyBefore).call.apply(_a, __spread([_this, values], params));
+                },
+                byIndex: function (position) { return _this.addManyByIndex(values, position); },
+                head: function () { return _this.addManyHead(values); },
+                tail: function () { return _this.addManyTail(values); },
+            };
+        };
+        LinkedList.prototype.addAfter = function (value, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attach(value, previous, previous.next) : this.addTail(value);
+        };
+        LinkedList.prototype.addBefore = function (value, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attach(value, next.previous, next) : this.addHead(value);
+        };
+        LinkedList.prototype.addByIndex = function (value, position) {
+            if (position < 0)
+                position += this.size;
+            else if (position >= this.size)
+                return this.addTail(value);
+            if (position <= 0)
+                return this.addHead(value);
+            var next = this.get(position);
+            return this.attach(value, next.previous, next);
+        };
+        LinkedList.prototype.addHead = function (value) {
+            var node = new ListNode(value);
+            node.next = this.first;
+            if (this.first)
+                this.first.previous = node;
+            else
+                this.last = node;
+            this.first = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addTail = function (value) {
+            var node = new ListNode(value);
+            if (this.first) {
+                node.previous = this.last;
+                this.last.next = node;
+                this.last = node;
+            }
+            else {
+                this.first = node;
+                this.last = node;
+            }
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addManyAfter = function (values, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attachMany(values, previous, previous.next) : this.addManyTail(values);
+        };
+        LinkedList.prototype.addManyBefore = function (values, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attachMany(values, next.previous, next) : this.addManyHead(values);
+        };
+        LinkedList.prototype.addManyByIndex = function (values, position) {
+            if (position < 0)
+                position += this.size;
+            if (position <= 0)
+                return this.addManyHead(values);
+            if (position >= this.size)
+                return this.addManyTail(values);
+            var next = this.get(position);
+            return this.attachMany(values, next.previous, next);
+        };
+        LinkedList.prototype.addManyHead = function (values) {
+            var _this = this;
+            return values.reduceRight(function (nodes, value) {
+                nodes.unshift(_this.addHead(value));
+                return nodes;
+            }, []);
+        };
+        LinkedList.prototype.addManyTail = function (values) {
+            var _this = this;
+            return values.map(function (value) { return _this.addTail(value); });
+        };
+        LinkedList.prototype.drop = function () {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropByIndex(position); },
+                byValue: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValue.apply(_this, params);
+                },
+                byValueAll: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValueAll.apply(_this, params);
+                },
+                head: function () { return _this.dropHead(); },
+                tail: function () { return _this.dropTail(); },
+            };
+        };
+        LinkedList.prototype.dropMany = function (count) {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropManyByIndex(count, position); },
+                head: function () { return _this.dropManyHead(count); },
+                tail: function () { return _this.dropManyTail(count); },
+            };
+        };
+        LinkedList.prototype.dropByIndex = function (position) {
+            if (position < 0)
+                position += this.size;
+            var current = this.get(position);
+            return current ? this.detach(current) : undefined;
+        };
+        LinkedList.prototype.dropByValue = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var position = this.findIndex(function (node) { return compareFn(node.value, value); });
+            return position < 0 ? undefined : this.dropByIndex(position);
+        };
+        LinkedList.prototype.dropByValueAll = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var dropped = [];
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (compareFn(current.value, value)) {
+                    dropped.push(this.dropByIndex(position - dropped.length));
+                }
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropHead = function () {
+            var head = this.first;
+            if (head) {
+                this.first = head.next;
+                if (this.first)
+                    this.first.previous = undefined;
+                else
+                    this.last = undefined;
+                this.size--;
+                return head;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropTail = function () {
+            var tail = this.last;
+            if (tail) {
+                this.last = tail.previous;
+                if (this.last)
+                    this.last.next = undefined;
+                else
+                    this.first = undefined;
+                this.size--;
+                return tail;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropManyByIndex = function (count, position) {
+            if (count <= 0)
+                return [];
+            if (position < 0)
+                position = Math.max(position + this.size, 0);
+            else if (position >= this.size)
+                return [];
+            count = Math.min(count, this.size - position);
+            var dropped = [];
+            while (count--) {
+                var current = this.get(position);
+                dropped.push(this.detach(current));
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropManyHead = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.unshift(this.dropHead());
+            return dropped;
+        };
+        LinkedList.prototype.dropManyTail = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.push(this.dropTail());
+            return dropped;
+        };
+        LinkedList.prototype.find = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return current;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.findIndex = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return position;
+            }
+            return -1;
+        };
+        LinkedList.prototype.forEach = function (callback) {
+            for (var node = this.first, position = 0; node; position++, node = node.next) {
+                callback(node, position, this);
+            }
+        };
+        LinkedList.prototype.get = function (position) {
+            return this.find(function (_, index) { return position === index; });
+        };
+        LinkedList.prototype.indexOf = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            return this.findIndex(function (node) { return compareFn(node.value, value); });
+        };
+        LinkedList.prototype.toArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node.value); });
+            return array;
+        };
+        LinkedList.prototype.toNodeArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node); });
+            return array;
+        };
+        LinkedList.prototype.toString = function (mapperFn) {
+            if (mapperFn === void 0) { mapperFn = JSON.stringify; }
+            return this.toArray()
+                .map(function (value) { return mapperFn(value); })
+                .join(' <-> ');
+        };
+        // Cannot use Generator type because of ng-packagr
+        LinkedList.prototype[Symbol.iterator] = function () {
+            var node, position;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.first, position = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!node) return [3 /*break*/, 4];
+                        return [4 /*yield*/, node.value];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        position++, node = node.next;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        };
+        return LinkedList;
+    }());
+
+    exports.LinkedList = LinkedList;
+    exports.ListNode = ListNode;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=abp-utils.umd.js.map

samples/MicroserviceDemo/applications/PublicWebSite.Host/wwwroot/libs/select2/js/select2-bootstrap-modal-patch.js

@@ -0,0 +1,4 @@
+/*
+    https://select2.org/troubleshooting/common-problems
+*/
+$.fn.modal.Constructor.prototype._enforceFocus = function () { };

samples/common.DotSettings

@@ -1 +0,0 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation" />

templates/app/angular/package.json

@@ -3,7 +3,7 @@
   "version": "0.0.0",
   "scripts": {
     "ng": "ng",
-    "start": "ng serve",
+    "start": "ng serve --open",
     "build": "ng build",
     "test": "ng test",
     "lint": "ng lint",

templates/app/angular/start.ps1

@@ -0,0 +1,2 @@
+yarn
+yarn start

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.HttpApi.HostWithIds/wwwroot/libs/abp/utils/abp-utils.umd.js

@@ -0,0 +1,600 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('just-compare')) :
+    typeof define === 'function' && define.amd ? define('@abp/utils', ['exports', 'just-compare'], factory) :
+    (global = global || self, factory((global.abp = global.abp || {}, global.abp.utils = global.abp.utils || {}, global.abp.utils.common = {}), global.compare));
+}(this, (function (exports, compare) { 'use strict';
+
+    compare = compare && Object.prototype.hasOwnProperty.call(compare, 'default') ? compare['default'] : compare;
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __exportStar(m, exports) {
+        for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    };
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+        return cooked;
+    };
+
+    function __importStar(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+        result.default = mod;
+        return result;
+    }
+
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+
+    function __classPrivateFieldGet(receiver, privateMap) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to get private field on non-instance");
+        }
+        return privateMap.get(receiver);
+    }
+
+    function __classPrivateFieldSet(receiver, privateMap, value) {
+        if (!privateMap.has(receiver)) {
+            throw new TypeError("attempted to set private field on non-instance");
+        }
+        privateMap.set(receiver, value);
+        return value;
+    }
+
+    /* tslint:disable:no-non-null-assertion */
+    var ListNode = /** @class */ (function () {
+        function ListNode(value) {
+            this.value = value;
+        }
+        return ListNode;
+    }());
+    var LinkedList = /** @class */ (function () {
+        function LinkedList() {
+            this.size = 0;
+        }
+        Object.defineProperty(LinkedList.prototype, "head", {
+            get: function () {
+                return this.first;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "tail", {
+            get: function () {
+                return this.last;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(LinkedList.prototype, "length", {
+            get: function () {
+                return this.size;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        LinkedList.prototype.attach = function (value, previousNode, nextNode) {
+            if (!previousNode)
+                return this.addHead(value);
+            if (!nextNode)
+                return this.addTail(value);
+            var node = new ListNode(value);
+            node.previous = previousNode;
+            previousNode.next = node;
+            node.next = nextNode;
+            nextNode.previous = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.attachMany = function (values, previousNode, nextNode) {
+            if (!values.length)
+                return [];
+            if (!previousNode)
+                return this.addManyHead(values);
+            if (!nextNode)
+                return this.addManyTail(values);
+            var list = new LinkedList();
+            list.addManyTail(values);
+            list.first.previous = previousNode;
+            previousNode.next = list.first;
+            list.last.next = nextNode;
+            nextNode.previous = list.last;
+            this.size += values.length;
+            return list.toNodeArray();
+        };
+        LinkedList.prototype.detach = function (node) {
+            if (!node.previous)
+                return this.dropHead();
+            if (!node.next)
+                return this.dropTail();
+            node.previous.next = node.next;
+            node.next.previous = node.previous;
+            this.size--;
+            return node;
+        };
+        LinkedList.prototype.add = function (value) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addAfter).call.apply(_a, __spread([_this, value], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addBefore).call.apply(_a, __spread([_this, value], params));
+                },
+                byIndex: function (position) { return _this.addByIndex(value, position); },
+                head: function () { return _this.addHead(value); },
+                tail: function () { return _this.addTail(value); },
+            };
+        };
+        LinkedList.prototype.addMany = function (values) {
+            var _this = this;
+            return {
+                after: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyAfter).call.apply(_a, __spread([_this, values], params));
+                },
+                before: function () {
+                    var _a;
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return (_a = _this.addManyBefore).call.apply(_a, __spread([_this, values], params));
+                },
+                byIndex: function (position) { return _this.addManyByIndex(values, position); },
+                head: function () { return _this.addManyHead(values); },
+                tail: function () { return _this.addManyTail(values); },
+            };
+        };
+        LinkedList.prototype.addAfter = function (value, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attach(value, previous, previous.next) : this.addTail(value);
+        };
+        LinkedList.prototype.addBefore = function (value, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attach(value, next.previous, next) : this.addHead(value);
+        };
+        LinkedList.prototype.addByIndex = function (value, position) {
+            if (position < 0)
+                position += this.size;
+            else if (position >= this.size)
+                return this.addTail(value);
+            if (position <= 0)
+                return this.addHead(value);
+            var next = this.get(position);
+            return this.attach(value, next.previous, next);
+        };
+        LinkedList.prototype.addHead = function (value) {
+            var node = new ListNode(value);
+            node.next = this.first;
+            if (this.first)
+                this.first.previous = node;
+            else
+                this.last = node;
+            this.first = node;
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addTail = function (value) {
+            var node = new ListNode(value);
+            if (this.first) {
+                node.previous = this.last;
+                this.last.next = node;
+                this.last = node;
+            }
+            else {
+                this.first = node;
+                this.last = node;
+            }
+            this.size++;
+            return node;
+        };
+        LinkedList.prototype.addManyAfter = function (values, previousValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var previous = this.find(function (node) { return compareFn(node.value, previousValue); });
+            return previous ? this.attachMany(values, previous, previous.next) : this.addManyTail(values);
+        };
+        LinkedList.prototype.addManyBefore = function (values, nextValue, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var next = this.find(function (node) { return compareFn(node.value, nextValue); });
+            return next ? this.attachMany(values, next.previous, next) : this.addManyHead(values);
+        };
+        LinkedList.prototype.addManyByIndex = function (values, position) {
+            if (position < 0)
+                position += this.size;
+            if (position <= 0)
+                return this.addManyHead(values);
+            if (position >= this.size)
+                return this.addManyTail(values);
+            var next = this.get(position);
+            return this.attachMany(values, next.previous, next);
+        };
+        LinkedList.prototype.addManyHead = function (values) {
+            var _this = this;
+            return values.reduceRight(function (nodes, value) {
+                nodes.unshift(_this.addHead(value));
+                return nodes;
+            }, []);
+        };
+        LinkedList.prototype.addManyTail = function (values) {
+            var _this = this;
+            return values.map(function (value) { return _this.addTail(value); });
+        };
+        LinkedList.prototype.drop = function () {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropByIndex(position); },
+                byValue: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValue.apply(_this, params);
+                },
+                byValueAll: function () {
+                    var params = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        params[_i] = arguments[_i];
+                    }
+                    return _this.dropByValueAll.apply(_this, params);
+                },
+                head: function () { return _this.dropHead(); },
+                tail: function () { return _this.dropTail(); },
+            };
+        };
+        LinkedList.prototype.dropMany = function (count) {
+            var _this = this;
+            return {
+                byIndex: function (position) { return _this.dropManyByIndex(count, position); },
+                head: function () { return _this.dropManyHead(count); },
+                tail: function () { return _this.dropManyTail(count); },
+            };
+        };
+        LinkedList.prototype.dropByIndex = function (position) {
+            if (position < 0)
+                position += this.size;
+            var current = this.get(position);
+            return current ? this.detach(current) : undefined;
+        };
+        LinkedList.prototype.dropByValue = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var position = this.findIndex(function (node) { return compareFn(node.value, value); });
+            return position < 0 ? undefined : this.dropByIndex(position);
+        };
+        LinkedList.prototype.dropByValueAll = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            var dropped = [];
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (compareFn(current.value, value)) {
+                    dropped.push(this.dropByIndex(position - dropped.length));
+                }
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropHead = function () {
+            var head = this.first;
+            if (head) {
+                this.first = head.next;
+                if (this.first)
+                    this.first.previous = undefined;
+                else
+                    this.last = undefined;
+                this.size--;
+                return head;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropTail = function () {
+            var tail = this.last;
+            if (tail) {
+                this.last = tail.previous;
+                if (this.last)
+                    this.last.next = undefined;
+                else
+                    this.first = undefined;
+                this.size--;
+                return tail;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.dropManyByIndex = function (count, position) {
+            if (count <= 0)
+                return [];
+            if (position < 0)
+                position = Math.max(position + this.size, 0);
+            else if (position >= this.size)
+                return [];
+            count = Math.min(count, this.size - position);
+            var dropped = [];
+            while (count--) {
+                var current = this.get(position);
+                dropped.push(this.detach(current));
+            }
+            return dropped;
+        };
+        LinkedList.prototype.dropManyHead = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.unshift(this.dropHead());
+            return dropped;
+        };
+        LinkedList.prototype.dropManyTail = function (count) {
+            if (count <= 0)
+                return [];
+            count = Math.min(count, this.size);
+            var dropped = [];
+            while (count--)
+                dropped.push(this.dropTail());
+            return dropped;
+        };
+        LinkedList.prototype.find = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return current;
+            }
+            return undefined;
+        };
+        LinkedList.prototype.findIndex = function (predicate) {
+            for (var current = this.first, position = 0; current; position++, current = current.next) {
+                if (predicate(current, position, this))
+                    return position;
+            }
+            return -1;
+        };
+        LinkedList.prototype.forEach = function (callback) {
+            for (var node = this.first, position = 0; node; position++, node = node.next) {
+                callback(node, position, this);
+            }
+        };
+        LinkedList.prototype.get = function (position) {
+            return this.find(function (_, index) { return position === index; });
+        };
+        LinkedList.prototype.indexOf = function (value, compareFn) {
+            if (compareFn === void 0) { compareFn = compare; }
+            return this.findIndex(function (node) { return compareFn(node.value, value); });
+        };
+        LinkedList.prototype.toArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node.value); });
+            return array;
+        };
+        LinkedList.prototype.toNodeArray = function () {
+            var array = new Array(this.size);
+            this.forEach(function (node, index) { return (array[index] = node); });
+            return array;
+        };
+        LinkedList.prototype.toString = function (mapperFn) {
+            if (mapperFn === void 0) { mapperFn = JSON.stringify; }
+            return this.toArray()
+                .map(function (value) { return mapperFn(value); })
+                .join(' <-> ');
+        };
+        // Cannot use Generator type because of ng-packagr
+        LinkedList.prototype[Symbol.iterator] = function () {
+            var node, position;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = this.first, position = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!node) return [3 /*break*/, 4];
+                        return [4 /*yield*/, node.value];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        position++, node = node.next;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        };
+        return LinkedList;
+    }());
+
+    exports.LinkedList = LinkedList;
+    exports.ListNode = ListNode;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=abp-utils.umd.js.map