@swimlane/ngx-datatable 11.1.4 → 11.2.0

package/src/directives/resizeable.directive.ts

@@ -1,10 +1,11 @@
 import {
-  Directive, ElementRef, HostListener, Input, Output, EventEmitter, OnDestroy, AfterViewInit
+  Directive, ElementRef, HostListener, Input, Output, EventEmitter, OnDestroy, AfterViewInit, Renderer2
 } from '@angular/core';
 import { Observable } from 'rxjs/Observable';
 import { Subscription } from 'rxjs/Subscription';
 import { MouseEvent } from '../events';
 import { takeUntil } from 'rxjs/operators';
+import { fromEvent } from 'rxjs/observable/fromEvent';
 
 @Directive({
   selector: '[resizeable]',
@@ -24,16 +25,19 @@ export class ResizeableDirective implements OnDestroy, AfterViewInit {
   subscription: Subscription;
   resizing: boolean = false;
 
-  constructor(element: ElementRef) {
+  constructor(element: ElementRef, private renderer: Renderer2) {
     this.element = element.nativeElement;
   }
 
   ngAfterViewInit(): void {
+    const renderer2 = this.renderer;
+    const node = renderer2.createElement('span');
     if (this.resizeEnabled) {
-      const node = document.createElement('span');
-      node.classList.add('resize-handle');
-      this.element.appendChild(node);
+      renderer2.addClass(node, 'resize-handle');
+    } else {
+      renderer2.addClass(node, 'resize-handle--not-resizable');
     }
+    renderer2.appendChild(this.element, node);
   }
 
   ngOnDestroy(): void {
@@ -59,11 +63,11 @@ export class ResizeableDirective implements OnDestroy, AfterViewInit {
       event.stopPropagation();
       this.resizing = true;
 
-      const mouseup = Observable.fromEvent(document, 'mouseup');
+      const mouseup = fromEvent(document, 'mouseup');
       this.subscription = mouseup
         .subscribe((ev: MouseEvent) => this.onMouseup());
 
-      const mouseMoveSub = Observable.fromEvent(document, 'mousemove')
+      const mouseMoveSub = fromEvent(document, 'mousemove')
         .pipe(takeUntil(mouseup))
         .subscribe((e: MouseEvent) => this.move(e, initialWidth, mouseDownScreenX));
 

package/src/events.ts

@@ -3,3 +3,4 @@ declare let global: any;
 /* tslint:disable:variable-name */
 export const MouseEvent = (global as any).MouseEvent as MouseEvent;
 export const KeyboardEvent = (global as any).KeyboardEvent as KeyboardEvent;
+export const Event = (global as any).Event as Event;

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './datatable.module';
 export * from './types';
 export * from './components';
+export * from './services';

package/src/services/dimensions-helper.service.ts

@@ -0,0 +1,14 @@
+import { Inject, Injectable } from '@angular/core';
+
+/**
+ * Gets the width of the scrollbar.  Nesc for windows
+ * http://stackoverflow.com/a/13382873/888165
+ */
+@Injectable()
+export class DimensionsHelper {
+
+  getDimensions(element: Element): ClientRect {
+    return element.getBoundingClientRect();
+  }
+
+}

package/src/services/index.ts

@@ -1 +1,2 @@
 export * from './scrollbar-helper.service';
+export * from './dimensions-helper.service';

package/src/utils/column-prop-getters.spec.ts

@@ -50,4 +50,48 @@ describe('deepValueGetter', () => {
     expect(deepValueGetter(data, 'a.b.value')).toEqual(5);
   });
 
+  it('should get array-element two-level deep', () => {
+    let data = {
+      a: {
+        b: [
+          123
+        ]
+      }
+    };
+    expect(deepValueGetter(data, 'a.b.0')).toEqual(123);
+
+  });
+
+  it('should get value of object inside an array-element', () => {
+    let data = {
+      a: {
+        b: [
+          {c: 123}
+        ]
+      }
+    };
+    expect(deepValueGetter(data, 'a.b.0.c')).toEqual(123);
+  });
+   it('should get value of object inside a double array-element', () => {
+    let data = {
+      a: {
+        b: [
+          [
+            123
+          ]
+        ]
+      }
+    };
+    expect(deepValueGetter(data, 'a.b.0.0')).toEqual(123);
+  });
+  
+
+  it('should check for root-level fields with square brackets in name', () => {
+    let data = {
+      'a.b.1.value': 5
+    };
+    expect(deepValueGetter(data, 'a.b.1.value')).toEqual(5);
+  });
+
+
 });

package/src/utils/column.ts

@@ -76,15 +76,3 @@ export function columnsByPinArr(val: any) {
 
   return colsByPinArr;
 }
-
-export function allColumnsByPinArr(val: any) {
-  const colsByPinArr = [];
-  const colsByPin = columnsByPin(val);
-  const colsTest = [];
-
-  colsByPinArr.push({ type: 'left', columns: colsByPin['left'] });
-  colsByPinArr.push({ type: 'center', columns: colsByPin['center'] });
-  colsByPinArr.push({ type: 'right', columns: colsByPin['right'] });
-
-  return colsByPinArr;
-}

package/src/utils/facade/browser.ts

@@ -0,0 +1,26 @@
+/*tslint:disable */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * JS version of browser APIs. This library can only run in the browser.
+ */
+var win = (typeof window !== 'undefined' && window) || <any>{};
+
+export { win as window };
+export var document = win.document;
+export var location = win.location;
+export var gc = win['gc'] ? () => win['gc']() : (): any => null;
+export var performance = win['performance'] ? win['performance'] : null;
+export const Event = win['Event'];
+export const MouseEvent = win['MouseEvent'];
+export const KeyboardEvent = win['KeyboardEvent'];
+export const EventTarget = win['EventTarget'];
+export const History = win['History'];
+export const Location = win['Location'];
+export const EventListener = win['EventListener'];

package/src/utils/math.ts

@@ -36,7 +36,7 @@ function scaleColumns(colsByGroup: any, maxWidth: any, totalFlexGrow: any) {
     for(const column of colsByGroup[attr]) {
       if (!column.canAutoResize) {
         maxWidth -= column.width;
-        totalFlexGrow -= column.flexGrow;
+        totalFlexGrow -= column.flexGrow ? column.flexGrow : 0;
       } else {
         column.width = 0;
       }

package/src/utils/sort.ts

@@ -51,18 +51,20 @@ export function orderByComparator(a: any, b: any): number {
 }
 
 /**
- * Sorts the rows
+ * creates a shallow copy of the `rows` input and returns the sorted copy. this function
+ * does not sort the `rows` argument in place
  */
 export function sortRows(rows: any[], columns: any[], dirs: SortPropDir[]): any[] {
   if(!rows) return [];
   if(!dirs || !dirs.length || !columns) return [...rows];
 
   /**
-   * create a mapping from each row to its row index prior to sorting
+   * record the row ordering of results from prior sort operations (if applicable)
+   * this is necessary to guarantee stable sorting behavior 
    */
   const rowToIndexMap = new Map<any, number>();
   rows.forEach((row, index) => rowToIndexMap.set(row, index));
-
+  
   const temp = [...rows];
   const cols = columns.reduce((obj, col) => {
     if(col.comparator && typeof col.comparator === 'function') {
@@ -107,6 +109,8 @@ export function sortRows(rows: any[], columns: any[], dirs: SortPropDir[]): any[
       if (comparison !== 0) return comparison;
     }
 
+    if (!(rowToIndexMap.has(rowA) && rowToIndexMap.has(rowB))) return 0;
+    
     /**
      * all else being equal, preserve original order of the rows (stable sort)
      */

package/test/index.ts

@@ -0,0 +1 @@
+export * from './jasmine-matchers';

package/test/jasmine-matchers.d.ts

@@ -0,0 +1,12 @@
+declare namespace jasmine {
+  interface Matchers<T> {
+    toHaveText(actual: any, expectationFailOutput?: any): jasmine.CustomMatcher;
+    toHaveCssClass(expected: any): boolean;
+  }
+}
+
+/*
+Copyright 2017-2018 Google Inc. All Rights Reserved.
+Use of this source code is governed by an MIT-style license that
+can be found in the LICENSE file at http://angular.io/license
+*/

package/test/jasmine-matchers.ts

@@ -0,0 +1,70 @@
+/// <reference path="./jasmine-matchers.d.ts" />
+
+export const addMatchers = () => jasmine.addMatchers({
+  toHaveText, toHaveCssClass
+});
+
+/**
+ * `toHaveText()` adapted from https://angular.io/guide/testing
+ */
+function toHaveText(): jasmine.CustomMatcher {
+  return {
+    compare(
+      actual: any,
+      expectedText: string,
+      expectationFailOutput?: any
+    ): jasmine.CustomMatcherResult {
+      const actualText = elementText(actual);
+      const pass = actualText.indexOf(expectedText) > -1;
+      const message = pass ? '' : composeMessage();
+      return { pass, message };
+
+      function composeMessage() {
+        const a =
+          actualText.length < 100
+            ? actualText
+            : actualText.substr(0, 100) + '...';
+        const efo = expectationFailOutput ? ` '${expectationFailOutput}'` : '';
+        return `Expected element to have text content '${expectedText}' instead of '${a}'${efo}`;
+      }
+    }
+  };
+}
+
+function elementText(n: any): string {
+  if (n instanceof Array) {
+    return n.map(elementText).join('');
+  }
+
+  if (n.nodeType === Node.COMMENT_NODE) {
+    return '';
+  }
+
+  if (n.nodeType === Node.ELEMENT_NODE && n.hasChildNodes()) {
+    return elementText(Array.prototype.slice.call(n.childNodes));
+  }
+
+  if (n.nativeElement) {
+    n = n.nativeElement;
+  }
+
+  return n.textContent;
+}
+
+/**
+ * adapted from https://github.com/ng-bootstrap/ng-bootstrap/blob/master/src/test/matchers.ts
+ */
+function toHaveCssClass(util, customEqualityTests) {
+  return { compare: buildError(false), negativeCompare: buildError(true) };
+
+  function buildError(isNot: boolean) {
+    return function(actual: HTMLElement, className: string) {
+      return {
+        pass: actual.classList.contains(className) === !isNot,
+        message: `Expected ${actual.outerHTML} ${
+          isNot ? 'not ' : ''
+        }to contain the CSS class "${className}"`
+      };
+    };
+  }
+}