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(this.width * this.width + this.height * this.height);
+  }
+}

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.
@@ -853,12 +851,11 @@ export class dom {
         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 +982,8 @@ export class dom {
         })
 
     }
+
+    static getScrollElement(): Element {
+        return document.scrollingElement || document.documentElement;
+    }
 }

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

@@ -0,0 +1,45 @@
+import { dom } from '../';
+import { domVectorf } from './dom-vectorf';
+
+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,60 @@
+/**
+ * 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';
+
+export class MatrixDom {
+  static parseFromString(str: string): MatrixDom {
+    if (str === 'none' || !str.length) {
+      return new MatrixDom();
+    }
+    const values =
+        str.slice('matrix('.length, -1)
+            .split(',')
+            .map((value) => parseFloat(value));
+    if (values.length !== 6 || values.some((value) => isNaN((value)))) {
+      throw new Error('Invalid matrix passed to MatrixDom.parseFromString');
+    }
+    return new MatrixDom(...values);
+  }
+
+  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: number = 1,
+      b: number = 0,
+      c: number = 0,
+      d: number = 1,
+      tx: number = 0,
+      ty: number = 0
+  ) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.d = d;
+    this.tx = tx;
+    this.ty = 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.spec.ts → src/map/array-map.spec.ts

@@ -1,4 +1,4 @@
-import { ArrayMap } from './array';
+import { ArrayMap } from './array-map';
 import test from 'ava';
 
 test('ArrayMap should always return an array', async t => {

src/map/array-map.ts

@@ -0,0 +1,11 @@
+import { DefaultMap } from './default-map';
+
+/**
+ * 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 DefaultMap<K, V[]> {
+  constructor(iterable: Array<[K, V[]]> = []) {
+    super(iterable, () => []);
+  }
+}

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

@@ -1,4 +1,4 @@
-import { DynamicDefaultMap } from './dynamic-default';
+import { DefaultMap } from './default-map';
 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-map.ts

@@ -0,0 +1,40 @@
+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)) {
+      const defaultValue = this.defaultFunction(key);
+      this.set(key, defaultValue);
+      return defaultValue;
+    } else {
+      return super.get(key);
+    }
+  }
+}