highmark-cli 0.0.135 → 0.0.138

package/src/position/relative.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import { PI } from "../constants";
+
+export default class RelativePosition {
+  constructor(top, left, time, speed, magnitude, direction) {
+    this.top = top;
+    this.left = left;
+    this.time = time;
+    this.speed = speed;
+    this.magnitude = magnitude;
+    this.direction = direction;
+  }
+
+  getTop() {
+    return this.top;
+  }
+
+  getLeft() {
+    return this.left;
+  }
+
+  getTime() {
+    return this.time;
+  }
+
+  getSpeed() {
+    return this.speed;
+  }
+
+  getMagnitude() {
+    return this.magnitude;
+  }
+
+  getDirection() {
+    return this.direction;
+  }
+
+  static fromFirstPositionAndSecondPosition(firstPosition, secondPosition) {
+    const position = secondPosition.minus(firstPosition),
+          top = position.getTop(),
+          left = position.getLeft(),
+          time = position.getTime(),
+          magnitude = Math.sqrt(top * top + left * left),
+          speed = (time === 0) ?
+                    0 :
+                      magnitude / time;
+
+    let direction;
+
+    if (left === 0) {
+      direction = (top < 0) ?
+                   +PI / 2 :
+                    -PI / 2;
+    } else {
+      direction = Math.atan2(-top, left);
+    }
+
+    const relativePosition = new RelativePosition(top, left, time, speed, magnitude, direction);
+
+    return relativePosition;
+  }
+}

package/src/position.js

@@ -1,11 +1,5 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
-import { PI, ONE_HUNDRED_AND_EIGHTY } from "./constants";
-
-const { first } = arrayUtilities;
-
 export default class Position {
   constructor(top, left, time, identifier) {
     this.top = top;
@@ -30,28 +24,6 @@ export default class Position {
     return this.identifier;
   }
 
-  getMagnitude() {
-    const magnitude = Math.sqrt(this.top * this.top + this.left * this.left);
-
-    return magnitude;
-  }
-
-  getDirection() {
-    let direction = 0;
-
-    if (this.left === 0) {
-      direction = (this.top < 0) ?
-                   +PI / 2 :
-                     -PI / 2;
-    } else {
-      direction = Math.atan2(-this.top, this.left);
-    }
-
-    direction = direction * ONE_HUNDRED_AND_EIGHTY / PI;
-
-    return direction;
-  }
-
   minus(position) {
     const positionTop = position.getTop(),
           positionLeft = position.getLeft(),
@@ -59,7 +31,7 @@ export default class Position {
           top = this.top - positionTop,
           left = this.left - positionLeft,
           time = this.time - positionTime,
-          identifier = null;  ///
+          identifier = this.identifier;
 
     position = new Position(top, left, time, identifier); ///
 
@@ -73,33 +45,23 @@ export default class Position {
     return matches;
   }
 
-  static fromMouseEvent(mouseEvent) {
-    const { pageX, pageY } = mouseEvent,
+  static fromTouch(touch) {
+    const { pageX, pageY, identifier } = touch,
           top = pageY,  ///
           left = pageX, ///
           time = getTime(),
-          identifier = null,
           position = new Position(top, left, time, identifier);
 
     return position;
   }
 
-  static fromTouchEvent(touchEvent) {
-    let position = null;
-
-    const { touches } = touchEvent,
-          touchesLength = touches.length;
-
-    if (touchesLength === 1) {
-      const firstTouch = first(touches),
-            touch = firstTouch, ///
-            { pageX, pageY, identifier } = touch,
-            top = pageY,
-            left = pageX,
-            time = getTime();
-
-      position = new Position(top, left, time, identifier);
-    }
+  static fromMouseEvent(mouseEvent) {
+    const { pageX, pageY } = mouseEvent,
+          top = pageY,  ///
+          left = pageX, ///
+          time = getTime(),
+          identifier = null,
+          position = new Position(top, left, time, identifier);
 
     return position;
   }

package/src/selectors.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const VIEW_DIV_SELECTOR = "body > div:not(.loading)";  ///
+export const LOADING_DIV_SELECTOR = "body > div.loading";
+export const VIEW_CHILD_DIVS_SELECTOR = "body > div:not(.loading) div"; ///

package/src/style.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export const menuDivHeight = "256px";

package/src/utilities/element.js

@@ -13,13 +13,18 @@ export function elementsFromDOMElements(domElements, Element) {
 }
 
 export function elementFromDOMElement(domElement, Element) {
-  const element = Element();  ///
+  const element = <Element/>;
 
   const { domElement: temporaryDOMElement } = element,
         { className: classNamesString } = temporaryDOMElement,
         classNames = classNamesString.split(SINGLE_SPACE);
 
-  const { classList } = domElement;
+  const { classList } = domElement,
+        { childNodes } = temporaryDOMElement;
+
+  childNodes.forEach((childNode) => {
+    domElement.appendChild(childNode);
+  });
 
   classNames.forEach((className) => {
     classList.add(className);

package/src/utilities/positions.js

@@ -0,0 +1,127 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import Position from "../position";
+
+const { clear, filter } = arrayUtilities;
+
+export function sortPositions(positionsA, positionsB) {
+  const positionAMap = positionsA.reduce((positionAMap, positionA) => {
+    const identifier = positionA.getIdentifier();
+
+    positionAMap[identifier] = positionA;
+
+    return positionAMap;
+  }, {});
+
+  clear(positionsA);
+
+  positionsB.forEach((positionB) => {
+    const identifier = positionB.getIdentifier(),
+          positionA = positionAMap[identifier];
+
+    positionsA.push(positionA);
+  });
+}
+
+export function matchPositions(positionsA, positionsB) {
+  let positionsMatch = false;
+
+  const positionsALength = positionsA.length,
+        positionsBLength = positionsB.length;
+
+  if (positionsALength === positionsBLength) {
+    const identifiersA = identifiersFromPositions(positionsA),
+          identifiersB = identifiersFromPositions(positionsB);
+
+    identifiersA.sort();
+
+    identifiersB.sort();
+
+    const identifiersMatch = identifiersA.every((identifierA, index) => {
+      const identifierB = identifiersB[index];
+
+      if (identifierA === identifierB) {
+        return true;
+      }
+    });
+
+    positionsMatch = identifiersMatch;  ///
+  }
+
+  return positionsMatch;
+}
+
+export function filterPositions(positionsA, positionsB) {
+  filter(positionsA, (positionA) => {
+    const matches = positionsB.some((positionB) => {
+      const matches = positionA.match(positionB);
+
+      if (matches) {
+        return true;
+      }
+    });
+
+    if (!matches) {
+      return true;
+    }
+  });
+}
+
+export function positionsFromMouseEvent(mouseEvent) {
+  const position = Position.fromMouseEvent(mouseEvent),
+        positions = [
+          position
+        ];
+
+  return positions;
+}
+
+export function positionsFromTouchEvent(touchEvent, changed = true) {
+  let touchesNodeList;
+
+  if (changed) {
+    ({ changedTouches: touchesNodeList } = touchEvent);
+  } else {
+    ({ touches: touchesNodeList } = touchEvent);
+  }
+
+  const touches = [
+          ...touchesNodeList
+        ],
+        positions = touches.map((touch) => {
+          const position = Position.fromTouch(touch);
+
+          return position;
+        });
+
+  compressPositions(positions);
+
+  return positions;
+}
+
+function compressPositions(positions) {
+  const positionMap = positions.reduce((positionMap, position) => {
+    const identifier = position.getIdentifier();
+
+    positionMap[identifier] = position;
+
+    return positionMap;
+  }, {});
+
+  positions = Object.values(positionMap);
+
+  return positions;
+}
+
+function identifiersFromPositions(positions) {
+  const identifiers = positions.map((position) => {
+    const identifier = position.getIdentifier();
+
+    return identifier;
+  });
+
+  return identifiers;
+}
+

package/src/view/div/leaf.js

@@ -4,21 +4,31 @@ import { Element } from "easy";
 
 import withStyle from "easy-with-style";  ///
 
-import eventMixins from "../../mixins/event";
-import touchMixins from "../../mixins/touch";
-
 class LeafDiv extends Element {
-  wiggle() {
-    this.removeClass("wiggle");
-    this.addClass("wiggle");
+  zoom(zoom) {
+    const width = `${100/zoom}%`,
+          minHeight = `${100/zoom}%`,
+          transform = `scale(${zoom})`;
+
+    const css = {
+      width,
+      minHeight,
+      transform
+    };
+
+    this.css(css);
   }
 
-  didMount() {
-    this.enableTouch();
+  setInitialState() {
+    const zoom = 1;
+
+    this.setState({
+      zoom
+    });
   }
 
-  willUnmount() {
-    this.disableTouch();
+  initialise() {
+    this.setInitialState();
   }
 
   static tagName = "div";
@@ -28,23 +38,10 @@ class LeafDiv extends Element {
   };
 }
 
-Object.assign(LeafDiv.prototype, eventMixins);
-Object.assign(LeafDiv.prototype, touchMixins);
-
 export default withStyle(LeafDiv)`
 
-  width: 100vw;
-  position: absolute;
-  min-height: 100vh;
+  width: 100%;
+  min-height: 100%;
+  transform-origin: top left;
   
-  @keyframes wiggle {
-    0% { transform: translateX(-5px); }
-    50% { transform: translateX(5px); }
-    100% { transform: translateX(-5px); }
-  }
-  
-  .wiggle {
-    animation: wiggle 0.5s ease-in-out 1;
-  }
-
 `;

package/src/view/div/menu.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import withStyle from "easy-with-style";
+
+import { Element } from "easy";
+
+import touchMixins from "../../mixins/touch";
+
+import { menuDivHeight } from "../../style";
+
+class MenuDiv extends Element {
+  customTapHandler = (event, element) => {
+    alert("MENU DIV TAP!")
+  }
+
+  didMount() {
+    this.enableTouch();
+
+    this.onCustomTap(this.customTapHandler);
+  }
+
+  willUnmount() {
+    this.disableTouch();
+
+    this.offCustomTap(this.customTapHandler);
+  }
+
+  initialise() {
+    this.hide();
+  }
+
+  parentContext() {
+    const showMenuDiv = this.show.bind(this),  ///
+          hideMenuDiv = this.hide.bind(this),  ///
+          isMenuDivDisplayed = this.isDisplayed.bind(this);  ///
+
+    return ({
+      showMenuDiv,
+      hideMenuDiv,
+      isMenuDivDisplayed
+    });
+  }
+
+  static tagName = "div";
+
+  static defaultProperties = {
+    className: "menu"
+  };
+}
+
+Object.assign(MenuDiv.prototype, touchMixins);
+
+export default withStyle(MenuDiv)`
+
+  left: 0;
+  width: 100%;
+  height: ${menuDivHeight};
+  bottom: 0;
+  position: fixed;
+  background-color: black;
+  
+`;