init weex project

Author: halfrost

.babelrc

@@ -0,0 +1 @@
+{ "presets": ["es2015"] }

.eslintrc

@@ -0,0 +1,18 @@
+{
+  "root": true,
+  "parser": "babel-eslint",
+  "parserOptions": {
+    "sourceType": "module"
+  },
+  "globals": {
+    "Vue": false,
+  },
+  "extends": "standard",
+  "plugins": [
+    "html"
+  ],
+  "rules": {
+    "arrow-parens": 0,
+    "generator-star-spacing": 0,
+  }
+}

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+config.js
+*log

app.js

@@ -0,0 +1,3 @@
+import foo from './src/foo.vue'
+foo.el = '#root'
+export default new Vue(foo);

assets/phantom-limb.js

@@ -0,0 +1,362 @@
+(function() {
+  // Phantom Limb
+  // ------------
+  // http://viewinglens.com/phantom-limb
+  // https://github.com/brian-c/phantom-limb
+  // brian.carstensen@gmail.com
+
+  "use strict";
+
+  // Default configuration
+  var config = {
+    style: true,
+    startOnLoad: true
+  };
+
+  // Apply overrides
+  for (var param in window.phantomLimbConfig) {
+    config[param] = window.phantomLimbConfig[param];
+  }
+
+  // Keep track of whether the mouse is down.
+  var mouseIsDown = false;
+
+  // A Finger is a representation on the screen.
+  // It keeps track of its position and the node that it's over.
+  function Finger() {
+    this.node = document.createElement('span');
+    this.node.classList.add('_phantom-limb_finger');
+    this.place();
+  }
+
+  Finger.prototype = {
+    node: null,
+
+    x: NaN,
+    y: NaN,
+
+    target: null,
+
+    place: function() {
+      document.body.appendChild(this.node);
+    },
+
+    hide: function() {
+      this.node.style.display = 'none';
+    },
+
+    show: function() {
+      this.node.style.display = '';
+    },
+
+    move: function(x, y) {
+      if (isNaN(x) || isNaN(y)) {
+        this.hide();
+        this.target = null;
+      } else {
+        this.show();
+
+        this.node.style.left = x + 'px';
+        this.node.style.top = y + 'px';
+
+        this.x = x;
+        this.y = y;
+
+        if (!mouseIsDown) this.target = document.elementFromPoint(x, y);
+      }
+    }
+  };
+
+  // We'll instantiate the fingers when we start.
+  var fingers = [];
+
+  // Create a synthetic event from a real event and a finger.
+  function createMouseEvent(eventName, originalEvent, finger) {
+    var e = document.createEvent('MouseEvent');
+
+    e.initMouseEvent(eventName, true, true,
+      originalEvent.view, originalEvent.detail,
+      finger.x || originalEvent.screenX, finger.y || originalEvent.screenY,
+      finger.x || originalEvent.clientX, finger.y || originalEvent.clientY,
+      originalEvent.ctrlKey, originalEvent.shiftKey,
+      originalEvent.altKey, originalEvent.metaKey,
+      originalEvent.button, finger.target || originalEvent.relatedTarget
+    );
+
+    e.synthetic = true;
+
+    // Set this so we can match shared targets later.
+    e._finger = finger;
+
+    return e;
+  }
+
+  var startDistance = NaN;
+  var startAngle = NaN;
+
+  // Given a mouse event, fire a touch event for each finger.
+  // Add the appropriate touch-specific event properties.
+  function fireTouchEvents(eventName, originalEvent) {
+    // All touch events, including "touchend".
+    var events = [];
+    var gestures = [];
+
+    // For each finger with a target, create a touch event.
+    fingers.forEach(function(finger) {
+      if (!finger.target) return;
+
+      // Convert "ontouch*" properties and attributes to listeners.
+      var onEventName = 'on' + eventName;
+
+      if (onEventName in finger.target) {
+        console.warn('Converting `' + onEventName + '` property to event listener.', finger.target);
+        finger.target.addEventListener(eventName, finger.target[onEventName], false);
+        delete finger.target[onEventName];
+      }
+
+      if (finger.target.hasAttribute(onEventName)) {
+        console.warn('Converting `' + onEventName + '` attribute to event listener.', finger.target);
+        var handler = new Function('event', finger.target.getAttribute(onEventName));
+        finger.target.addEventListener(eventName, handler, false);
+        finger.target.removeAttribute(onEventName);
+      }
+
+      // Set up a new event with the coordinates of the finger.
+      var touch = createMouseEvent(eventName, originalEvent, finger);
+
+      events.push(touch);
+    });
+
+    // Figure out scale and rotation.
+    if (events.length > 1) {
+      var x = events[0].pageX - events[1].pageX;
+      var y = events[0].pageY - events[1].pageY;
+
+      var distance = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
+      var angle = Math.atan2(x, y) * (180 / Math.PI);
+
+      var gestureName = 'gesturechange';
+
+      if (eventName === 'touchstart') {
+        gestureName = 'gesturestart';
+        startDistance = distance;
+        startAngle = angle;
+      }
+
+      if (eventName === 'touchend') gestureName = 'gestureend';
+
+      events.forEach(function(event) {
+        var gesture = createMouseEvent(gestureName, event, event._finger);
+        gestures.push(gesture);
+      });
+
+      events.concat(gestures).forEach(function(event) {
+        event.scale = distance / startDistance;
+        event.rotation = startAngle - angle;
+      });
+    }
+
+    // Loop through the events array and fill in each touch array.
+    events.forEach(function(touch) {
+      touch.touches = events.filter(function(e) {
+        return ~e.type.indexOf('touch') && e.type !== 'touchend';
+      });
+
+      touch.changedTouches = events.filter(function(e) {
+        return ~e.type.indexOf('touch') && e._finger.target === touch._finger.target;
+      });
+
+      touch.targetTouches = touch.changedTouches.filter(function(e) {
+        return ~e.type.indexOf('touch') && e.type !== 'touchend';
+      });
+    });
+
+    // Then fire the events.
+    events.concat(gestures).forEach(function(event, i) {
+      event.identifier = i;
+      event._finger.target.dispatchEvent(event);
+    });
+  }
+
+  // Prevent all mousedown event from doing anything.
+  // We'll fire one manually at touchend.
+  function phantomTouchStart(e) {
+    if (e.synthetic) return;
+
+    mouseIsDown = true;
+
+    e.preventDefault();
+    e.stopPropagation();
+
+    fireTouchEvents('touchstart', e);
+  }
+
+  // The center between two fingers
+  var centerX = NaN;
+  var centerY = NaN;
+
+  // Set each finger's position target.
+  // Pressing alt engages the second finger.
+  // Pressing shift locks the second finger's position relative to the first's.
+  function moveFingers(e) {
+    // We'll use this if the second is locked with the first.
+    var changeX = e.clientX - fingers[0].x || 0;
+    var changeY = e.clientY - fingers[0].y || 0;
+
+    // The first finger just follows the mouse.
+    fingers[0].move(e.clientX, e.clientY);
+
+    // TODO: Determine modifier keys independent of mouse movement.
+
+    if (e.altKey) {
+      // Reset the center.
+      if (!centerX && !centerY) {
+        centerX = innerWidth / 2;
+        centerY = innerHeight / 2;
+      }
+
+      // Lock the center with the first finger.
+      if (e.shiftKey) {
+        centerX += changeX;
+        centerY += changeY;
+      }
+
+      var secondX = centerX + (centerX - e.clientX);
+      var secondY = centerY + (centerY - e.clientY);
+
+      fingers[1].move(secondX, secondY);
+    } else {
+      // Disengage the second finger.
+      fingers[1].move(NaN, NaN);
+
+      // Reset the center next time the alt key is held.
+      centerX = NaN;
+      centerY = NaN;
+    }
+  }
+
+  // Prevent all mousemove events from firing.
+  // We'll fire one (and only one) manually at touchend.
+  function phantomTouchMove(e) {
+    if (e.synthetic) return;
+
+    e.preventDefault();
+    e.stopPropagation();
+
+    moveFingers(e);
+
+    if (mouseIsDown) {
+      fireTouchEvents('touchmove', e);
+    }
+  }
+
+  // Prevent all mouseup events from firing.
+  // We'll fire one manually at touchend.
+  function phantomTouchEnd(e) {
+    if (e.synthetic) return;
+
+    mouseIsDown = false;
+
+    e.preventDefault();
+    e.stopPropagation();
+
+    fireTouchEvents('touchend', e);
+
+    fingers.forEach(function(finger) {
+      if (!finger.target) return;
+
+      // Mobile Safari moves all the mouse event to fire after the touchend event.
+      finger.target.dispatchEvent(createMouseEvent('mouseover', e, finger));
+      finger.target.dispatchEvent(createMouseEvent('mousemove', e, finger));
+      finger.target.dispatchEvent(createMouseEvent('mousedown', e, finger));
+
+      // TODO: These two only fire if content didn't change. How can we tell?
+      finger.target.dispatchEvent(createMouseEvent('mouseup', e, finger));
+      finger.target.dispatchEvent(createMouseEvent('click', e, finger));
+    });
+  }
+
+  // Prevent clicks. We'll handle them manually.
+  function phantomClick(e) {
+    if (e.synthetic) return;
+
+    e.preventDefault();
+    e.stopPropagation();
+  }
+
+  // Not entirely proud of this, but I can't serve CSS from GitHub
+  // and I want the bookmarklet to be as simple as possible.
+  var defaultCSS = ([
+    '._phantom-limb,',
+    '._phantom-limb a {',
+      'cursor: none !important;',
+    '}',
+    '._phantom-limb_finger {',
+      'background: rgba(128, 128, 128, 0.5);',
+      'border: 2px solid rgb(128, 128, 128);',
+      'border-radius: 50%;',
+      'display: none;',
+      'height: 44px;',
+      'margin: -22px 0 0 -22px;',
+      'pointer-events: none;',
+      'position: fixed;',
+      'width: 44px;',
+      'z-index: 999999' +
+    '}',
+    '._phantom-limb ._phantom-limb_finger {',
+      'display: block;',
+    '}'
+  ]).join('\n');
+
+  if (config.style) {
+    var styleTag = document.createElement('style');
+    styleTag.id = '_phantom-limb_default-style';
+    styleTag.innerHTML = defaultCSS;
+    document.querySelector('head').appendChild(styleTag);
+  }
+
+  // On/off switch
+  function start() {
+    if (fingers.length === 0) fingers.push(new Finger(), new Finger());
+
+    document.addEventListener('mousedown', phantomTouchStart, true);
+    document.addEventListener('mousemove', phantomTouchMove, true);
+    document.addEventListener('mouseup', phantomTouchEnd, true);
+    document.addEventListener('click', phantomClick, true);
+
+    document.documentElement.classList.add('_phantom-limb');
+  }
+
+  function stop() {
+    document.removeEventListener('mousedown', phantomTouchStart, true);
+    document.removeEventListener('mousemove', phantomTouchMove, true);
+    document.removeEventListener('mouseup', phantomTouchEnd, true);
+    document.removeEventListener('click', phantomClick, true);
+
+    document.documentElement.classList.remove('_phantom-limb');
+  }
+
+  // Detect keyup, exit when esc.
+  function phantomKeyUp(e) {
+    if (e.keyCode === 27) {
+      if (document.documentElement.classList.contains('_phantom-limb')) {
+        stop();
+      } else {
+        start();
+      }
+    }
+  }
+
+  var phantomLimb = {
+    start: start,
+    stop: stop
+  };
+
+  if (typeof define === 'function' && define.amd) define(phantomLimb);
+  if (typeof module !== 'undefined') module.exports = phantomLimb;
+  window.phantomLimb = phantomLimb;
+
+  document.addEventListener('keyup', phantomKeyUp, false);
+
+  if (config.startOnLoad) addEventListener('DOMContentLoaded', start, false);
+}());