Add Dimensions2d class

src/arrayf/arrayf.ts

@@ -28,22 +28,6 @@ export class arrayf {
         return output;
     }
 
-    /**
-     * Zips arrays together. zip(['a', 'b'], [1, 2]) becomes
-     * [['a', 1], ['b', 2]]
-     */
-    static zip<T>(...lists: T[][]): T[][] {
-        const result = [];
-        let i = 0;
-        let remainingLists = lists.filter((list) => list.length > i);
-        while (remainingLists.length) {
-            result[i] = remainingLists.map((list) => list[i]);
-            i++;
-            remainingLists = remainingLists.filter((list) => list.length > i);
-        }
-        return result;
-    }
-
     /**
      * Return value from array that generates the highest return value when
      * passed as a parameter to the score function.
@@ -67,5 +51,4 @@ export class arrayf {
         });
         return maxValue;
     }
-
 }

src/dom/dimensions-2d-dom.ts

@@ -0,0 +1,21 @@
+export class Dimensions2dDom {
+  static fromElementOffset(element: HTMLElement) {
+    return new Dimensions2dDom(element.offsetWidth, element.offsetHeight);
+  }
+  width: number;
+  height: number;
+
+  constructor(width: number, height: number) {
+    this.width = width;
+    this.height = height;
+  }
+
+  equals(candidate: Dimensions2dDom) {
+    return this.width === candidate.width &&
+        this.height === candidate.height;
+  }
+
+  getHypotenuseLength() {
+    return Math.sqrt(Math.pow(this.width, 2) + Math.pow(this.height, 2));
+  }
+}

src/dom/dom-vectorf.ts

@@ -0,0 +1,15 @@
+import { MatrixDom } from './matrix-dom';
+import { Vector } from '../mathf/vector';
+
+/**
+ * DOM version of Vector2d with various DOM-specific helper functions.
+ */
+export class domVectorf {
+  static fromMatrix<T extends Vector>(matrix: MatrixDom): T {
+    return <T>new Vector(matrix.getTranslateX(), matrix.getTranslateY());
+  }
+
+  static fromElementTransform<T extends Vector>(element: Element): T {
+    return this.fromMatrix(MatrixDom.fromElementTransform(element));
+  }
+}

src/dom/dom.ts

@@ -480,8 +480,6 @@ export class dom {
         return window.getComputedStyle(element);
     }
 
-
-
     /**
      * Creates an image in memory that is later deletable so it can
      * be released from native memory AND image cache.
@@ -849,16 +847,14 @@ export class dom {
      *
      * ```
      */
-    static getStyle(el: Element): CSSStyleDeclaration {
-        return el['currentStyle'] || window.getComputedStyle(el);
+    static getStyle(el: Element): CSSStyleDeclaration {return el['currentStyle'] || window.getComputedStyle(el);
     }
 
-
     /**
      * Tests whether the provided element is set to display none.
      */
     static isDisplayNone(el: Element): boolean {
-        let style = window.getComputedStyle(el, null).display;
+        let style = window.getComputedStyle(el).display;
         return style == 'none';
     }
 
@@ -985,4 +981,8 @@ export class dom {
         })
 
     }
+
+    static getScrollElement(): Element {
+        return document.scrollingElement || document.documentElement;
+    }
 }

src/dom/get-visible-y-from-root.ts

@@ -0,0 +1,47 @@
+import { dom } from '../';
+import { domVectorf } from './dom-vectorf';
+
+const ignoredPositions = new Set(['fixed', 'absolute']);
+
+function isFixed(element: HTMLElement) {
+  return dom.getStyle(element).position === 'fixed';
+}
+
+function getTransformedOffset(candidateElement: HTMLElement): number {
+  return candidateElement.offsetTop +
+      domVectorf.fromElementTransform(candidateElement).y;
+}
+
+function getVisibleDistanceFromRoot(
+    element: HTMLElement,
+    getOffsetFn: (e: HTMLElement) => number
+): number {
+  // Short circuit for fixed elements
+  if (isFixed(element)) {
+    return element.offsetTop;
+  }
+
+  // Loop through offset parents and tally the distance
+  let candidateElement: HTMLElement = <HTMLElement>element.offsetParent;
+  let y = 0;
+  while (candidateElement && candidateElement !== document.body) {
+    // Special case for fixed elements
+    if (isFixed(candidateElement)) {
+      return y + candidateElement.offsetTop;
+    } else {
+      // Factor in the offset and the scroll
+      y += getOffsetFn(candidateElement) - candidateElement.scrollTop;
+    }
+    candidateElement = <HTMLElement>candidateElement.offsetParent;
+  }
+
+  return getOffsetFn(element) + y - dom.getScrollElement().scrollTop;
+}
+
+/**
+ * Returns the visible distance between the top of the given element and the
+ * top of the viewport.
+ */
+export function getVisibleYFromRoot(element: HTMLElement) {
+  return getVisibleDistanceFromRoot(element, getTransformedOffset);
+}

src/dom/matrix-dom.ts

@@ -0,0 +1,55 @@
+/**
+ * Class for dealing with CSS Transform matrices.
+ * Supports relative updates being made to a matrix from multiple pieces of
+ * code without them over-riding each other (unless explicitly desired).
+ */
+import { dom } from './dom';
+
+type Numeric = number|string; // Number that could be represented as string
+
+export class MatrixDom {
+  static parseFromString(str: string): MatrixDom {
+    if (str === 'none' || !str.length) {
+      return new MatrixDom();
+    }
+    return new MatrixDom(...str.slice('matrix('.length, -1).split(','));
+  }
+
+  static fromElementTransform(element: Element): MatrixDom {
+    const transform = dom.getStyle(element).transform;
+    return MatrixDom.parseFromString(transform);
+  }
+
+  // Values a, b, c, d, tx, ty as per CSS transforms
+  readonly a: number;
+  readonly b: number;
+  readonly c: number;
+  readonly d: number;
+  readonly tx: number;
+  readonly ty: number;
+
+  // Use numeric to allow strings or numbers
+  constructor(
+      a: Numeric = 1,
+      b: Numeric = 0,
+      c: Numeric = 0,
+      d: Numeric = 1,
+      tx: Numeric = 0,
+      ty: Numeric = 0
+  ) {
+    this.a = parseFloat(<string>a);
+    this.b = parseFloat(<string>b);
+    this.c = parseFloat(<string>c);
+    this.d = parseFloat(<string>d);
+    this.tx = parseFloat(<string>tx);
+    this.ty = parseFloat(<string>ty);
+  }
+
+  getTranslateX(): number {
+    return this.tx;
+  }
+
+  getTranslateY(): number {
+    return this.ty;
+  }
+}

src/dom/webgl-image-sequence.ts

@@ -982,7 +982,6 @@ export class WebGlImageSequence {
 
 
     private async draw(imageSource: string | null) {
-
         // Prevent invalid draws
         if (!imageSource || this.disposed) {
             return;
@@ -991,6 +990,12 @@ export class WebGlImageSequence {
         if (imageSource == this.lastDrawSource) {
             return;
         }
+
+        // Can't draw on a 0 area canvas
+        if (!this.canvasWidth || !this.canvasHeight) {
+            return;
+        }
+
         this.lastDrawSource = imageSource;
 
 
@@ -1001,7 +1006,7 @@ export class WebGlImageSequence {
                 // the very last draw call is always rendered.
                 this.lastDrawSource = null;
                 this.draw(imageSource);
-            })
+            });
             return;
         }
 
@@ -1204,8 +1209,6 @@ export class WebGlImageSequence {
         this.lastRenderSource = imageSource;
     }
 
-
-
     /**
      * Updates the internal sizing options.
      * @param options
@@ -1296,4 +1299,4 @@ export class WebGlImageSequence {
         this.gl = null;
     }
 
-}
+}

src/map/array.ts

@@ -1,18 +1,11 @@
-import { DynamicDefaultMap } from './dynamic-default';
-import { MapWrapper } from './map-wrapper';
+import { DefaultMap } from './default';
 
 /**
  * A map where the values in the map are all expected to be arrays.
  * When calling get(K) for an unset key K, we are returned and empty array.
  */
-export class ArrayMap<K, V> extends MapWrapper<K, V[]> {
-  constructor(iterable: Array<[K, V[]]> = [],
-              InnerMapClass: typeof Map = Map) {
-    super(iterable, InnerMapClass);
-    this.replaceInnerMap(
-      new DynamicDefaultMap<K, V[]>(
-        iterable,
-        InnerMapClass,
-        (key: K) => []));
+export class ArrayMap<K, V> extends DefaultMap<K, V[]> {
+  constructor(iterable: Array<[K, V[]]> = []) {
+    super(iterable, () => []);
   }
 }

src/map/dynamic-default.spec.ts → src/map/default.spec.ts

@@ -1,4 +1,4 @@
-import { DynamicDefaultMap } from './dynamic-default';
+import { DefaultMap } from './default';
 import test from 'ava';
 
 const testDefaultFns = [
@@ -7,38 +7,38 @@ const testDefaultFns = [
   (x: number) => `${x}!`
 ];
 
-test('DynamicDefaultMap should generate default values', async t => {
+test('DefaultMap should generate default values', async t => {
   testDefaultFns.forEach((defaultFn) => {
-    const map = new DynamicDefaultMap<number, any>([], Map, defaultFn);
+    const map = new DefaultMap<number, any>([], defaultFn);
     for (let i = -1; i < 2; i++) {
       t.is(map.get(i), defaultFn(i));
     }
   });
 });
 
-test('DynamicDefaultMap should not generate defaults over set values', async t => {
+test('DefaultMap should not generate defaults over set values', async t => {
   testDefaultFns.forEach((defaultFn) => {
-    const map = new DynamicDefaultMap<number, any>([], Map, defaultFn);
+    const map = new DefaultMap<number, any>([], defaultFn);
     for (let i = -1; i < 2; i++) {
       map.set(i, i);
       t.is(map.get(i), i);
     }
   });
 });
 
-test('DynamicDefaultMap should not generate defaults over initialized values', async t => {
+test('DefaultMap should not generate defaults over initialized values', async t => {
   testDefaultFns.forEach((defaultFn) => {
     const testValues: Array<[number, any]> = [[-1, -1], [0, 0], [1, 1]];
-    const map = new DynamicDefaultMap<number, any>(testValues, Map, defaultFn);
+    const map = new DefaultMap<number, any>(testValues, defaultFn);
     for (let i = -1; i < 2; i++) {
       t.is(map.get(i), i);
     }
   });
 });
 
-test('DynamicDefaultMap usingFunction should return an empty map using the given function to generate defaults', async t => {
+test('DefaultMap usingFunction should return an empty map using the given function to generate defaults', async t => {
   testDefaultFns.forEach((defaultFn) => {
-    const map = DynamicDefaultMap.usingFunction<number, any>(defaultFn);
+    const map = DefaultMap.usingFunction<number, any>(defaultFn);
     for (let i = -1; i < 2; i++) {
       map.set(i, i);
       t.is(map.get(i), i);

src/map/default.ts

@@ -0,0 +1,37 @@
+import { noop } from '../func/noop';
+
+type DefaultFunction<K, V> = (key: K) => V;
+/**
+ * Allows for returning generated defaults for unknown keys.
+ * Useful as a quick and dirty way to cache results of functions.
+ *
+ * This is intended to behave similarly to the defaultdict structure in python.
+ *
+ * ```
+ * const sqrRts =
+ *     DefaultMap.usingFunction<number, number>((x) => Math.sqrt(x));
+ * sqrRts.get(9); // Returns 3
+ * ```
+ */
+export class DefaultMap<K, V> extends Map<K, V> {
+  static usingFunction<K, V>(
+      defaultFunction: DefaultFunction<K, V>
+  ): DefaultMap<K, V> {
+    return new this([], defaultFunction);
+  }
+
+  private readonly defaultFunction: DefaultFunction<K, V>;
+
+  constructor(iterable: Array<[K, V]> = [],
+              defaultFunction: DefaultFunction<K, V> = noop) {
+    super(iterable);
+    this.defaultFunction = defaultFunction;
+  }
+
+  get(key: K): V {
+    if (!this.has(key)) {
+      this.set(key, this.defaultFunction(key));
+    }
+    return super.get(key);
+  }
+}