Merge branch 'master' into ibarakov/fix-5813-10.2.x

Author: igdmdimitrov

CHANGELOG.md

@@ -29,6 +29,21 @@ All notable changes for each version of this project will be documented in this
 - `IgxGrid`, `IgxTreeGrid`, `IgxHierarchicalGrid`
     - When triggering an export of the grid via the toolbar and the export takes more than 500 milliseconds, the export button becomes disabled and an indeterminate progress bar is shown at the bottom of the toolbar until the export is finished.
     - Added *getRowData(rowSelector)* method that returns an object that represents the data that is contained in the specified row component.
+    - Added ability to spawn row adding UI through exoposed methods. Note that rowEditing should be enabled.
+        - `beginAddRow` method which starts the adding row UI.
+        - `beginAddChild` method which starts the adding child UI.
+        ```typescript
+        this.grid.beginAddRow(rowID);
+        ```
+        - Added an input properties to `IgxGridEditingActions` component to show/hide add row and add child buttons which trigger the UI based on context expression.
+        ```html
+        <igx-tree-grid [rowEditing]="true">
+            <igx-action-strip #actionStrip>
+                <igx-grid-editing-actions [addRow]="true" [addChild]="actionStrip.context.level < 3">
+                </igx-grid-editing-actions>
+            </igx-action-strip>
+        </igx-tree-grid>
+        ```
 - ` IGX_INPUT_GROUP_TYPE` injection token
     - Allows for setting an input group `type` on a global level, so all input-group instances, including components using such an instance as a template will have their input group type set to the one specified by the token. It can be overridden on a component level by explicitly setting a `type`.
 - ` IgxExcelExporterService`
@@ -41,6 +56,10 @@ All notable changes for each version of this project will be documented in this
 - `IgxOverlay`
     - The `PositionSettings` `target` property has been deprecated and moved to `OverlaySettings`.
     - An optional Point/HTML Element parameter `target` has been added to the `position()` method
+- `IgxToast`
+    - The component now utilizes the `IgxOverlayService` to position itself in the DOM.
+    - An additional input property `outlet` has been added to allow users to specify custom Overlay Outlets using the `IgxOverlayOutletDirective`;
+    - The `position` property now accepts values of type `IgxToastPosition` that work with strict templates.
 
 ## 10.1.0
 

projects/igniteui-angular/migrations/common/ServerHost.ts

@@ -0,0 +1,183 @@
+import { Tree } from '@angular-devkit/schematics';
+import * as ts from 'typescript/lib/tsserverlibrary';
+
+export class ServerHost implements ts.server.ServerHost {
+    readonly args: string[];
+    readonly newLine: string;
+    readonly useCaseSensitiveFileNames: boolean;
+
+    constructor(private host: Tree) {
+        this.args = ts.sys.args;
+        this.newLine = ts.sys.newLine;
+        this.useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
+    }
+
+    public readFile(path: string, encoding?: string): string | undefined {
+        let content;
+        try {
+            content = this.host.read(path).toString(encoding);
+        } finally {
+            return content || ts.sys.readFile(path, encoding);
+        }
+    }
+
+    public getFileSize(path: string): number {
+        return ts.sys.getFileSize(path);
+    }
+
+    public watchFile(path: string, callback: ts.FileWatcherCallback, pollingInterval?: number):
+        ts.FileWatcher {
+        return ts.sys.watchFile(path, callback, pollingInterval);
+    }
+
+    public watchDirectory(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean):
+        ts.FileWatcher {
+        return ts.sys.watchDirectory(path, callback, recursive);
+    }
+
+    public resolvePath(path: string): string {
+        return ts.sys.resolvePath(path);
+    }
+
+    public fileExists(path: string): boolean {
+        return this.host.exists(path);
+    }
+
+    public directoryExists(path: string): boolean {
+        let exists: boolean;
+        try {
+            exists = this.host.getDir(path) !== void 0;
+        } finally {
+            return exists || this.fileExists(path);
+        }
+    }
+
+    public getExecutingFilePath(): string {
+        return ts.sys.getExecutingFilePath();
+    }
+
+    public getCurrentDirectory(): string {
+        return this.host.root.path;
+    }
+
+    public getDirectories(path: string): string[] {
+        return this.host.getDir(path).subdirs;
+    }
+
+    public readDirectory(path: string): string[] {
+        return this.host.getDir(path).subfiles;
+    }
+
+    public require(initialPath: string, moduleName: string) {
+        try {
+            const modulePath = require.resolve(moduleName, {
+                paths: [initialPath],
+            });
+            return {
+                module: require(modulePath),
+                error: undefined,
+            };
+        } catch (e) {
+            return {
+                module: undefined,
+                error: e as Error,
+            };
+        }
+    }
+
+    public getModifiedTime(path: string): Date | undefined {
+        return ts.sys.getModifiedTime(path);
+    }
+
+    public realpath(path: string): string {
+        return ts.sys.realpath(path);
+    }
+
+    public createSHA256Hash(data: string): string {
+        return ts.sys.createSHA256Hash(data);
+    }
+
+    //#region Not implemented methods
+
+    public write(data: string): void {
+        throw new Error('Method "write" not implemented.');
+        // ts.sys.write(data);
+    }
+
+    public writeOutputIsTTY(): boolean {
+        throw new Error('Method "writeOutputIsTTY" not implemented.');
+        // return ts.sys.writeOutputIsTTY();
+    }
+
+    public writeFile(path: string, data: string, writeByteOrderMark?: boolean): void {
+        throw new Error('Method "writeFile" not implemented.');
+        // return ts.sys.writeFile(path, data, writeByteOrderMark);
+    }
+
+    public createDirectory(path: string): void {
+        throw new Error('Method "createDirectory" not implemented.');
+        // return ts.sys.createDirectory(path);
+    }
+
+    public setModifiedTime(path: string, time: Date): void {
+        throw new Error('Method "setModifiedTime" not implemented.');
+        // return ts.sys.setModifiedTime(path, time);
+    }
+
+    public deleteFile(path: string): void {
+        throw new Error('Method "deleteFile" not implemented.');
+        // return ts.sys.deleteFile(path);
+    }
+
+    public createHash(data: string): string {
+        throw new Error('Method "createHash" not implemented.');
+        // return ts.sys.createHash(data);
+    }
+
+    public getMemoryUsage(): number {
+        throw new Error('Method "getMemoryUsage" not implemented.');
+        // return ts.sys.getMemoryUsage();
+    }
+
+    public exit(exitCode?: number): void {
+        throw new Error('Method "exit" not implemented.');
+        // return ts.sys.exit(exitCode);
+    }
+
+    public setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any {
+        throw new Error('Method "setTimeout" not implemented.');
+        // return ts.sys.setTimeout(callback, ms, ...args);
+    }
+
+    public clearTimeout(timeoutId: any): void {
+        throw new Error('Method "clearTimeout" not implemented.');
+        // return ts.sys.clearTimeout(timeoutId);
+    }
+
+    public clearScreen(): void {
+        throw new Error('Method "clearScreen" not implemented.');
+        // return ts.sys.clearScreen();
+    }
+
+    public base64decode(input: string): string {
+        throw new Error('Method "base64decode" not implemented.');
+        // return ts.sys.base64decode(input);
+    }
+
+    public base64encode(input: string): string {
+        throw new Error('Method "base64encode" not implemented.');
+        // return ts.sys.base64encode(input);
+    }
+
+    public setImmediate(callback: (...args: any[]) => void, ...args: any[]): any {
+        throw new Error('Method "setImmediate" not implemented.');
+        // return setImmediate(callback, ...args);
+    }
+
+    public clearImmediate(timeoutId: any): void {
+        throw new Error('Method "clearImmediate" not implemented.');
+        // return clearImmediate(timeoutId);
+    }
+
+    //#endregion
+}