// 安装vue脚手架工具
npm install vue-cli -g

// 初始化webpack应用
vue init webpack vue-music

// 背景图片
bg-image($url)
  background-image: url($url + "@2x.png")
  @media (-webkit-min-device-pixel-ratio: 3),(min-device-pixel-ratio: 3)
    background-image: url($url + "@3x.png")

// 不换行
no-wrap()
  text-overflow: ellipsis
  overflow: hidden
  white-space: nowrap

// 扩展点击区域
extend-click()
  position: relative
  &:before
    content: ''
    position: absolute
    top: -10px
    left: -10px
    right: -10px
    bottom: -10px

resolve: {
    extensions: ['.js', '.vue', '.json'],
    alias: {
      '@': resolve('src'),
      'common': resolve('src/common')
    }
}

npm install fastclick --save

import FastClick from 'fastclick';

FastClick.attach(document.body);

npm install jsonp --save

import originJSONP from 'jsonp';

/**
 * 做一个简单的jsonp封装
 * @param url
 * @param data
 * @param option
 * @return {Promise}
 */
export default function jsonp (url, data, option) {
  return new Promise((resolve, reject) => {
    url = `${url}?${_obj2String(data)}`;
    originJSONP(url, option, (err, data) => {
      if (!err) {
        resolve(data);
      } else {
        reject(err);
      }
    });
  });
};

function _obj2String (obj, arr = [], index = 0) {
  for (let item in obj) {
    arr[index++] = [item, obj[item]];
  }
  return new URLSearchParams(arr).toString();
}

import BScroll from 'better-scroll';

let wrapper = document.querySelector('.wrapper');
let scroll = new BScroll(wrapper,{
    // 配置项
});

.wrapper
    position: fixed
    width: 100%
    top: 88px
    bottom: 0
    .scroll
        height: 100%
        overflow: hidden

proxyTable: {
  '/getDescList': {
    target: 'http://127.0.0.1:7070/desclist', // 后端接口地址
    changeOrigin: true,
    // secure: false,
    pathRewrite: {
      '^/getDescList': '/'
    }
  }
}

export default new Router({
    routes:[
        {
            path: '/',
            component: Singer,
            children: [
                {
                    path: ':id',
                    compoonent: SingerDetail
                }
            ]
        },
        ...
    ]
});

this.$router.push({
  path: `singer/${singer.id}`
});

// 别忘了在`Singer`页面中：
<router-view></router-view>

npm install vuex --save

import Vuex from 'vuex';
import Vue from 'Vue';

Vue.use(Vuex);

import store from './store';
..

new Vue({
    el: '#app',
    store,
    render: h => h(App)
});

dom.addEventListener('touchstart',(e) => {
    // 获取事件类型
    let type = e.type;
    // toch事件发生时那个位置的元素对象
    let target = e.target;    
    
});

// 获取touchList
let touchList = e.changedTouches;
// 获取第i个touch对象
let touch = touchList[i];

touch.screenX
touch.clientX
touch.pageX
touch.target
...

dom.addEventListener('touchstart',(e) => {
    // 这个 TouchList对象列出了和这个触摸事件对应的那些发生了变化的 Touch 对象
    e.changedTouches
    // 这个TouchList列出了那些 touchstart发生在这个元素，并且还没有离开 touch surface 的touch point(手指)
    e.targetTouches
    // 这个 TouchList 列出了事件触发时： touch suface上所有的 touch point。
    e.touches
});

<audio>
</audio>

let audio = this.$refs.audio;
// 暂停和播放
audio.pause();
audio.play();

// Audio对象的属性（部分）

audio.currentTime // 设置或返回音频中的当前播放位置（以秒计）。

audio.duration    // 返回音频的长度（以秒计）。

audio.loop    // 设置或返回音频是否应在结束时再次播放。（默认false）

audio.volume    // 设置或返回音频的音量。[0,1]

// Audio对象多媒体事件（Media Events）

onerror // 加载发生错误时的回调

ontimeupdate // 当播放位置改变时调用
updateTime(e) {
    if(this.currentSongReady){
        // 获取当前播放的进度
        this.currentSongTime=e.traget.currentTime;
    }
}
oncanplay // 能够播放时调用

// 通过监听这个事件，设置标志位，这个标志位可以帮助我们
// 防止用户快速切换歌曲引起一些错误。
songCanPlay(){
    this.currentSongReady = true;
}


onended // 到达结尾时调用

onplay、onpause...

<p>
</p>

// 首先得定义一个`touch`对象
let touch = {};

// 在监听的方法中
touchStart(e){
    this.touch.initialized = true;
    // 获取touch的起始位置
    this.touch.startX = e.touches[0].pageX;
    // 获取整个进度条的宽度
    this.touch.barW = xxx;
    // 获取已经播放的进度
    this.touch.offset = xxx;    
}

touchMove(e){
    // 判断有无初始化
    ...
    // 获取用户滑动的距离
    let deltaX = e.touches[0].pageX - this.touch.startX;
    let barW = xxx; // 进度条的宽度 - 拖动btn的宽度
    let offset = Math.min(Math.max(0, this.touch.offset + detail), barW);
    
    // 最后设置btn的位置和progress的进度就OK
    ...
}

touchEnd(){
    this.touch.initialized = false;
    // 然后将进度推送出去就好了
    this.$emit('percentChange',percent);
}

<template>
  <p>
    <svg>
      <circle></circle>
      <circle></circle>
    </svg>
    <slot></slot>
  </p>
</template>

// 全屏显示
document.documentElement.webkitRequestFullScreen();
// 退出全屏
document.webkitExitFullscreen();

// 1.得根据不同的浏览器添加前缀
// 2.程序主动调用不管用，得用户操作才可以（点击按钮）

if (lineNum > 5) {
  let elements = this.$refs.lyricLine;
  this.$refs.lyricScroll.scrollToElement(elements[lineNum - 5], 1000);
} else {
  this.$refs.lyricScroll.scrollTo(0, 0, 1000);
}

import { mapGetters } from 'vuex';

export const playListMixin = {

  mounted () {
    this.handlePlayList(this.playList);
  },
  // 当路由对应的页面激活时调用
  activated () {
    this.handlePlayList(this.playList);
  },
  watch: {
    playList (newPlayList) {
      this.handlePlayList(newPlayList);
    }
  },
  computed: {
    ...mapGetters([
      'playList'
    ])
  },
  methods: {
      // 这个方法需要对应的组件自己去实现，直接调用抛出错误
    handlePlayList () {
      throw new Error('Components must implement handlePlayList method.');
    }
  }
};

import { playListMixin } from 'common/js/mixin';

export default{
    mixins: [playListMixin],
    ...
}

// 在created钩子中，我们监听用户输入字符串（query）变化，然后将变化后的字符串
// 提交给父组件

// 可以看到在回调函数中，又包了一层debounce函数

created () {
  this.$watch('query', debounce(() => {
    this.$emit('queryChange', this.query);
  }, 500));
}

function debounce(func,delay){
    let timer = null;
    return function(...args){
        if(timer){
            clearTimeout(timer);
        }
        timer = setTimeout(()=>{
            func.apply(this,args);
        },delay)        
    }
}

// 测试
function show(){
    console.log('hello...');
}

var func = debounce(show,3000);

// 调用
func(); 

// 连续调用时，没有超过三秒是不会有任何输出的

const __VERSION__ = '1.0.1';
const store = {
  version: __VERSION__,
  storage: window.localStorage,
  session: {
    storage: window.sessionStorage
  }
};

// 操作store的api
const api = {
  set (key, val) {
    if (this.disabled) {
      return false;
    }
    if (val === undefined) {
      return this.remove(key);
    }
    this.storage.setItem(key, this.serialize(val));
    return val;
  },
  get (key, val) {
    if (this.disabled) {
      return false;
    }
    let result = this.storage.getItem(key);
    if (!result) {
      return val;
    }
    return this.deSerialize(result);
  },
  getAll () {
    if (this.disabled) {
      return false;
    }
    let ret = {};
    for (let key in this.storage) {
      if (this.storage.hasOwnProperty(key)) {
        ret[key] = this.get(key);
      }
    }
    return ret;
  },
  remove (key) {
    if (this.disabled) {
      return false;
    }
    this.storage.removeItem(key);
  },
  removeAll () {
    if (this.disabled) {
      return false;
    }
    this.storage.clear();
  },
  forEach (cb) {
    if (this.disabled) {
      return false;
    }
    for (let key in this.storage) {
      if (this.storage.hasOwnProperty(key)) {
        cb && cb(key, this.get(key));
      }
    }
  },
  has (key) {
    if (this.disabled) {
      return false;
    }
    return key === this.get(key);
  },
  serialize (val) {
    try {
      return JSON.stringify(val) || undefined;
    } catch (e) {
      return undefined;
    }
  },
  deSerialize (val) {
    if (typeof val !== 'string') {
      return undefined;
    }
    try {
      return JSON.parse(val) || undefined;
    } catch (e) {
      return undefined;
    }
  }
};

// 扩展store对象
Object.assign(store, api);
Object.assign(store.session, api);

// 浏览器能力检测
try {
  let testKey = 'test_key';
  store.set(testKey, testKey);
  if (store.get(testKey) !== testKey) {
    store.disabled = true;
  }
  store.remove(testKey);
} catch (e) {
  store.disabled = true;
}

export default store;

const AsyncComponent = () => ({
  // 需要加载的组件 (应该是一个 `Promise` 对象)
  component: import('./MyComponent.vue'),
  // 异步组件加载时使用的组件
  loading: LoadingComponent,
  // 加载失败时使用的组件
  error: ErrorComponent,
  // 展示加载时组件的延时时间。默认值是 200 (毫秒)
  delay: 200,
  // 如果提供了超时时间且组件加载也超时了，
  // 则使用加载失败时使用的组件。默认值是：`Infinity`
  timeout: 3000
})

// import Recommend from '@/components/recommend/recommend';
const Recommend = () => ({
  component: import('@/components/recommend/recommend')
});