const conditional = require('koa-conditional-get');
const etag = require('koa-etag');
const Koa = require('koa');
const app = new Koa();

// etag works together with conditional-get
app.use(conditional());
app.use(etag());

app.use(function (ctx) {
  ctx.body = 'Hello World';
});

app.listen(3000);

console.log('listening on port 3000');

'use strict'
const calculate = require('etag')
const Stream = require('stream')
const promisify = require('util').promisify
const fs = require('fs')

const stat = promisify(fs.stat)

/**
 * Expose `etag`.
 * Add ETag header field.
 * @param {object} [options] see https://github.com/jshttp/etag#options
 * @param {boolean} [options.weak]
 * @return {Function}
 * @api public
 */
module.exports = function etag (options) {
  return async function etag (ctx, next) {
    // 先进行后续的中间件逻辑，之后再处理etag
    await next()
    const entity = await getResponseEntity(ctx)
    setEtag(ctx, entity, options)
  }
}

async function getResponseEntity (ctx) {
  // 如果没有body，或已存在etag，则return跳出
  const body = ctx.body
  if (!body || ctx.response.get('etag')) return

  // 获取http状态码 第一位数字
  const status = ctx.status / 100 | 0

  // 2xx 除2xx的非正常情况都跳出
  if (status !== 2) return

  // 1、如果为流，返回fs.stat调用后的文件信息对象
  // 2、如果为字符串或buffer则直接返回
  // 3、否则转为字符串返回
  if (body instanceof Stream) {
    if (!body.path) return
    return await stat(body.path)
  } else if ((typeof body === 'string') || Buffer.isBuffer(body)) {
    return body
  } else {
    return JSON.stringify(body)
  }
}

function setEtag (ctx, entity, options) {
  // 如果body，即响应体不存在则不设置tag
  if (!entity) return

  // 调用etag能力并设置到响应头etag中
  ctx.response.etag = calculate(entity, options)
}

var copy = require('copy-to');
 
var src = {
  _name: 'foo',
  set name(val) {
    this._name = val;
  },
  get name() {
    return this._name;
  },
  show: function () {
    console.log(this._name);
  }
};
 
var des = {
  _name: 'bar'
};
 
copy(src).to(des);
copy(src).toCover(des);
copy(src).pick('_name', 'name').to(des);
copy(src).pick('_name', 'name').toCover(des);

copy(src).withAccess().and(other).to(des); // 包括构造器属性

'use strict';
var slice = Array.prototype.slice;

/**
 * Expose copy
 *
 * ```
 * copy({foo: 'nar', hello: 'copy'}).to({hello: 'world'});
 * copy({foo: 'nar', hello: 'copy'}).toCover({hello: 'world'});
 * ```
 *
 * @param {Object} src
 * @return {Copy}
 */

module.exports = Copy;

/**
 * 核心的copy方法
 * @param {Object} src
 * @param {Boolean} withAccess
 */
function Copy(src, withAccess) {
  // 一种写法的兼容，可以直接调用Copy相当于new Copy
  if (!(this instanceof Copy)) return new Copy(src, withAccess);
  // 设置源对象和目标对象
  this.src = src;
  this._withAccess = withAccess;
}

/**
 * 复制属性包括 getter 和 setter
 * @param {[type]} val [description]
 * @return {[type]} [description]
 */
Copy.prototype.withAccess = function (w) {
  this._withAccess = w !== false;
  return this;
};

/**
 * 指定 src 对象的某些属性
 * @api: public
 */
Copy.prototype.pick = function (keys) {
  if (!Array.isArray(keys)) {
    keys = slice.call(arguments);
  }
  if (keys.length) {
    this.keys = keys;
  }
  return this;
};

/**
 * copy src to target,
 * do not cover any property target has
 * @param {Object} to
 * @api: public
 */
Copy.prototype.to = function (to) {
  to = to || {};

  if (!this.src) return to;
  var keys = this.keys || Object.keys(this.src);

  // _withAccess默认undefined即不考虑构造器，调用
  if (!this._withAccess) {
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      if (to[key] !== undefined) continue;
      to[key] = this.src[key];
    }
    return to;
  }

  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    // 如果该属性存在跳过，即不覆盖
    if (!notDefined(to, key)) continue;
    var getter = this.src.__lookupGetter__(key);
    var setter = this.src.__lookupSetter__(key);
    if (getter) to.__defineGetter__(key, getter);
    if (setter) to.__defineSetter__(key, setter);

    if (!getter && !setter) {
      to[key] = this.src[key];
    }
  }
  return to;
};

/**
 * 从src对象复制到to对象，并且覆盖目标对象已有的属性
 * @param {Object} to
 * @api: public
 */
Copy.prototype.toCover = function (to) {
  var keys = this.keys || Object.keys(this.src);

  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    delete to[key];
    var getter = this.src.__lookupGetter__(key);
    var setter = this.src.__lookupSetter__(key);
    if (getter) to.__defineGetter__(key, getter);
    if (setter) to.__defineSetter__(key, setter);

    if (!getter && !setter) {
      to[key] = this.src[key];
    }
  }
};

Copy.prototype.override = Copy.prototype.toCover;

/**
 * 添加其他对象到src中
 * @param {Obj} obj
 * @return {Copy}
 */
Copy.prototype.and = function (obj) {
  var src = {};
  this.to(src);
  this.src = obj;
  this.to(src);
  this.src = src;

  return this;
};

/**
 * 检查 obj[key] 是否存在
 * @param {Object} obj
 * @param {String} key
 * @return {Boolean}
 */
function notDefined(obj, key) {
  return obj[key] === undefined
    && obj.__lookupGetter__(key) === undefined
    && obj.__lookupSetter__(key) === undefined;
}

var Koa = require('koa');
var bodyParser = require('koa-bodyparser');
 
var app = new Koa();
app.use(bodyParser());
 
app.use(async ctx => {
  // the parsed body will store in ctx.request.body
  // if nothing was parsed, body will be an empty object {}
  ctx.body = ctx.request.body;
});

'use strict';
const parse = require('co-body');
const copy = require('copy-to');

/**
 * @param [Object] opts
 *   - {String} jsonLimit default '1mb'
 *   - {String} formLimit default '56kb'
 *   - {string} encoding default 'utf-8'
 *   - {Object} extendTypes
 */

module.exports = function (opts) {
  opts = opts || {};
  const { detectJSON } = opts;
  const { onerror } = opts;

  // 获取可用类型，以及各类型可用的布尔值
  const enableTypes = opts.enableTypes || ['json', 'form'];
  const enableForm = checkEnable(enableTypes, 'form');
  const enableJson = checkEnable(enableTypes, 'json');
  const enableText = checkEnable(enableTypes, 'text');
  const enableXml = checkEnable(enableTypes, 'xml');

  opts.detectJSON = undefined;
  opts.onerror = undefined;

  // 使 co-body 返回 raw body
  opts.returnRawBody = true;

  // 默认的 json 类型
  const jsonTypes = [
    'application/json',
    'application/json-patch+json',
    'application/vnd.api+json',
    'application/csp-report'
  ];

  // 默认的 form 类型
  const formTypes = ['application/x-www-form-urlencoded'];

  // 默认的 text 类型
  const textTypes = ['text/plain'];

  // 默认的 xml 类型
  const xmlTypes = ['text/xml', 'application/xml'];

  // 格式化成对应类型的参数
  const jsonOpts = formatOptions(opts, 'json');
  const formOpts = formatOptions(opts, 'form');
  const textOpts = formatOptions(opts, 'text');
  const xmlOpts = formatOptions(opts, 'xml');

  // 这里通过参数扩展自定义的type类型
  const extendTypes = opts.extendTypes || {};
  extendType(jsonTypes, extendTypes.json);
  extendType(formTypes, extendTypes.form);
  extendType(textTypes, extendTypes.text);
  extendType(xmlTypes, extendTypes.xml);

  // 返回中间件
  return async function bodyParser(ctx, next) {
    // 如果请求体为空或禁用则跳出
    if (ctx.request.body !== undefined || ctx.disableBodyParser)
      return await next();
    try {
      const res = await parseBody(ctx);
      ctx.request.body = 'parsed' in res ? res.parsed : {};
      if (ctx.request.rawBody === undefined) ctx.request.rawBody = res.raw;
    } catch (err) {
      if (onerror) {
        // 自定义错误处理函数
        onerror(err, ctx);
      } else {
        throw err;
      }
    }

    await next();
  };

  // 使用co-body的parse转换请求内容
  async function parseBody(ctx) {
    if (
      enableJson &&
      ((detectJSON && detectJSON(ctx)) || ctx.request.is(jsonTypes))
    ) {
      return await parse.json(ctx, jsonOpts);
    }

    if (enableForm && ctx.request.is(formTypes)) {
      return await parse.form(ctx, formOpts);
    }

    if (enableText && ctx.request.is(textTypes)) {
      return (await parse.text(ctx, textOpts)) || '';
    }

    if (enableXml && ctx.request.is(xmlTypes)) {
      return (await parse.text(ctx, xmlOpts)) || '';
    }

    return {};
  }
};

function formatOptions(opts, type) {
  const res = {};
  // 将opts复制到res中并返回
  copy(opts).to(res);
  res.limit = opts[type + 'Limit'];
  return res;
}

function extendType(original, extend) {
  if (extend) {
    if (!Array.isArray(extend)) {
      extend = [extend];
    }

    extend.forEach(function (extend) {
      original.push(extend);
    });
  }
}

function checkEnable(types, type) {
  return types.includes(type);
}

is (type, ...types) {
  return typeis(this.req, type, ...types)
},

parseurl({url:'http://www.baidu.com?q=ni&s=shuo&a=shenme'})

Url {
  protocol: 'http:',
  slashes: true,
  auth: null,
  host: 'www.baidu.com',
  port: null,
  hostname: 'www.baidu.com',
  hash: null,
  search: '?q=ni&s=shuo&a=shenme',
  query: 'q=ni&s=shuo&a=shenme',
  pathname: '/',
  path: '/?q=ni&s=shuo&a=shenme',
  href: 'http://www.baidu.com/?q=ni&s=shuo&a=shenme',
  _raw: 'http://www.baidu.com?q=ni&s=shuo&a=shenme'
}

'use strict'

var url = require('url')
var parse = url.parse
var Url = url.Url

module.exports = parseurl
module.exports.original = originalurl

/**
 * parse转化 `req` 中的 url，同时使用缓存
 * @param {ServerRequest} req
 * @return {Object}
 * @public
 */
function parseurl(req) {
  var url = req.url

  if (url === undefined) {
    // URL 是 undefined 时直接返回
    return undefined
  }

  var parsed = req._parsedUrl

  if (fresh(url, parsed)) {
    // 如果当前记录的为最新的 url，则直接返回之前parse过的结果
    return parsed
  }

  // 转化 URL
  // 转化前url存在_raw，转化后url存在_parsedUrl
  // _parsedUrl即为缓存的内容
  parsed = fastparse(url)
  parsed._raw = url

  return (req._parsedUrl = parsed)
};

/**
 * 转化 `req`对象的 original url
 *
 * @param {ServerRequest} req
 * @return {Object}
 * @public
 */
function originalurl(req) {
  var url = req.originalUrl

  if (typeof url !== 'string') {
    // Fallback
    return parseurl(req)
  }

  var parsed = req._parsedOriginalUrl

  if (fresh(url, parsed)) {
    // Return cached URL parse
    return parsed
  }

  // Parse the URL
  parsed = fastparse(url)
  parsed._raw = url

  return (req._parsedOriginalUrl = parsed)
};

/**
 * Parse the `str` url with fast-path short-cut.
 *
 * @param {string} str
 * @return {Object}
 * @private
 */
function fastparse(str) {
  // 如果参数不为字符串则使用node中的url.parse去转换
  if (typeof str !== 'string' || str.charCodeAt(0) !== 0x2f /* / */) {
    return parse(str)
  }

  var pathname = str
  var query = null
  var search = null

  // This takes the regexp from https://github.com/joyent/node/pull/7878
  // Which is /^(\/[^?#\s]*)(\?[^#\s]*)?$/
  // And unrolls it into a for loop
  // 通过判断 ? 来截取后边的 query字串
  for (var i = 1; i < str.length; i++) {
    switch (str.charCodeAt(i)) {
      case 0x3f: /* ?  */
        if (search === null) {
          pathname = str.substring(0, i)
          query = str.substring(i + 1)
          search = str.substring(i)
        }
        break
      case 0x09: /* \t */
      case 0x0a: /* \n */
      case 0x0c: /* \f */
      case 0x0d: /* \r */
      case 0x20: /*    */
      case 0x23: /* #  */
      case 0xa0:
      case 0xfeff:
        return parse(str)
    }
  }

  var url = Url !== undefined
    ? new Url()
    : {}

  url.path = str
  url.href = str
  url.pathname = pathname

  if (search !== null) {
    url.query = query
    url.search = search
  }

  return url
}

/**
 * 判断之前转化过的 url 是否是最新的
 * @param {string} url
 * @param {object} parsedUrl
 * @return {boolean}
 * @private
 */
function fresh(url, parsedUrl) {
  // 判断 parsedUrl 为不为空的对象，且为Url的实例，且raw记录的url为当前传入的url 
  return typeof parsedUrl === 'object' &&
    parsedUrl !== null &&
    (Url === undefined || parsedUrl instanceof Url) &&
    parsedUrl._raw === url
}

'use strict';

// 自身不等则一定是NaN
var numberIsNaN = function (value) {
  return value !== value;
};

module.exports = function is(a, b) {
  // 排除 +0 === -0 为true，因为 +Infinity !== -Infinity
  if (a === 0 && b === 0) {
    return 1 / a === 1 / b;
  }
  if (a === b) {
    return true;
  }
  // 排除 NaN === NaN 为false
  if (numberIsNaN(a) && numberIsNaN(b)) {
    return true;
  }
  return false;
};

window.open("域名/template.xlsx(文件名)");

function getBlob(url) {
  return new Promise(resolve => {
    const xhr = new XMLHttpRequest();

    xhr.open('GET', url, true);
    xhr.responseType = 'blob';
    xhr.onload = () => {
      if (xhr.status === 200) {
        resolve(xhr.response);
      }
    };

    xhr.send();
  });
}

function saveAs(blob, filename) {
  if (window.navigator.msSaveOrOpenBlob) {
    navigator.msSaveBlob(blob, filename);
  } else {
    const link = document.createElement('a');

    link.href = window.URL.createObjectURL(blob);
    link.download = filename;
    link.click();

    window.URL.revokeObjectURL(link.href);
  }
}

function download(url, filename) {
  getBlob(url).then(blob => {
    saveAs(blob, filename);
  });
}

// For Example
download('https://github.com/vuejs/vue-router', 'vue-router.html');

// 获取当前全局对象
var _global = typeof window === 'object' && window.window === window
  ? window : typeof self === 'object' && self.self === self
    ? self : typeof global === 'object' && global.global === global
      ? global
      : this

// 返回blob对象
function bom(blob, opts) {
  if (typeof opts === 'undefined') opts = { autoBom: false }
  else if (typeof opts !== 'object') {
    console.warn('Deprecated: Expected third argument to be a object')
    opts = { autoBom: !opts }
  }

  // 为UTF-8 XML 和 text/* 类型 (包括 HTML)准备 BOM
  // 笔记: 浏览器会自动转换 UTF-16 U+FEFF 到 EF BB BF
  if (opts.autoBom && /^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
    return new Blob([String.fromCharCode(0xFEFF), blob], { type: blob.type })
  }
  return blob
}

// 主要的download下载函数，通过创建XMLHttpRequest发送请求
function download(url, name, opts) {
  var xhr = new XMLHttpRequest()
  xhr.open('GET', url)
  xhr.responseType = 'blob'
  xhr.onload = function () {
    // 在拿到响应的数据后，根据不同客户端情况，有不同解决方案
    saveAs(xhr.response, name, opts)
  }
  xhr.onerror = function () {
    console.error('could not download file')
  }
  xhr.send()
}

function corsEnabled(url) {
  var xhr = new XMLHttpRequest()
  // use sync to avoid popup blocker
  xhr.open('HEAD', url, false)
  try {
    xhr.send()
  } catch (e) { }
  return xhr.status >= 200 && xhr.status <= 299
}

// `a.click()` 不是在所有浏览器都起作用 (#465)
// 这里是一种兼容写法，dispatchEvent派发click点击事件，若抛错。则创建并执行自定义的鼠标点击事件
function click(node) {
  try {
    node.dispatchEvent(new MouseEvent('click'))
  } catch (e) {
    var evt = document.createEvent('MouseEvents')
    evt.initMouseEvent('click', true, true, window, 0, 0, 0, 80,
      20, false, false, false, false, 0, null)
    node.dispatchEvent(evt)
  }
}

// Detect WebView inside a native macOS app by ruling out all browsers
// We just need to check for 'Safari' because all other browsers (besides Firefox) include that too
// https://www.whatismybrowser.com/guides/the-latest-user-agent/macos
var isMacOSWebView = _global.navigator && /Macintosh/.test(navigator.userAgent) && /AppleWebKit/.test(navigator.userAgent) && !/Safari/.test(navigator.userAgent)

var saveAs = _global.saveAs || (
  // 可能处在web worker中，无法通过window访问，默认不执行其他操作
  (typeof window !== 'object' || window !== _global)
    ? function saveAs() { /* noop */ }

    // 尽可能先用download属性 (#193 Lumia mobile) 除非它是macOS类浏览器
    : ('download' in HTMLAnchorElement.prototype && !isMacOSWebView)
      ? function saveAs(blob, name, opts) {
        var URL = _global.URL || _global.webkitURL
        var a = document.createElement('a')
        name = name || blob.name || 'download'

        a.download = name
        a.rel = 'noopener' // tabnabbing

        // TODO: detect chrome extensions & packaged apps
        // a.target = '_blank'

        if (typeof blob === 'string') {
          // Support regular links
          a.href = blob
          if (a.origin !== location.origin) {
            corsEnabled(a.href)
              ? download(blob, name, opts)
              : click(a, a.target = '_blank')
          } else {
            click(a)
          }
        } else {
          // 支持blobs时
          a.href = URL.createObjectURL(blob)
          setTimeout(function () { URL.revokeObjectURL(a.href) }, 4E4) // 40s
          setTimeout(function () { click(a) }, 0)
        }
      }

      // 使用msSaveOrOpenBlob作为第二方案，兼容IE10以上
      : 'msSaveOrOpenBlob' in navigator
        ? function saveAs(blob, name, opts) {
          name = name || blob.name || 'download'

          if (typeof blob === 'string') {
            if (corsEnabled(blob)) {
              download(blob, name, opts)
            } else {
              var a = document.createElement('a')
              a.href = blob
              a.target = '_blank'
              setTimeout(function () { click(a) })
            }
          } else {
            navigator.msSaveOrOpenBlob(bom(blob, opts), name)
          }
        }

        // 最后保守方案使用FileReader和弹出窗口
        : function saveAs(blob, name, opts, popup) {
          // Open a popup immediately do go around popup blocker
          // Mostly only available on user interaction and the fileReader is async so...
          popup = popup || open('', '_blank')
          if (popup) {
            popup.document.title =
              popup.document.body.innerText = 'downloading...'
          }

          if (typeof blob === 'string') return download(blob, name, opts)

          var force = blob.type === 'application/octet-stream'
          var isSafari = /constructor/i.test(_global.HTMLElement) || _global.safari
          var isChromeIOS = /CriOS\/[\d]+/.test(navigator.userAgent)

          if ((isChromeIOS || (force && isSafari) || isMacOSWebView) && typeof FileReader !== 'undefined') {
            // Safari不支持blob URLs的下载
            var reader = new FileReader()
            reader.onloadend = function () {
              var url = reader.result
              url = isChromeIOS ? url : url.replace(/^data:[^;]*;/, 'data:attachment/file;')
              if (popup) popup.location.href = url
              else location = url
              popup = null // reverse-tabnabbing #460
            }
            reader.readAsDataURL(blob)
          } else {
            var URL = _global.URL || _global.webkitURL
            var url = URL.createObjectURL(blob)
            if (popup) popup.location = url
            else location.href = url
            popup = null // reverse-tabnabbing #460
            setTimeout(function () { URL.revokeObjectURL(url) }, 4E4) // 40s
          }
        }
)

_global.saveAs = saveAs.saveAs = saveAs

if (typeof module !== 'undefined') {
  module.exports = saveAs;
}

function has(browser) {
  const ua = navigator.userAgent;
  if (browser === 'ie') {
    const isIE = ua.indexOf('compatible') > -1 && ua.indexOf('MSIE') > -1;
    if (isIE) {
      const reIE = new RegExp('MSIE (\\d+\\.\\d+);');
      reIE.test(ua);
      return parseFloat(RegExp['$1']);
    } else {
      return false;
    }
  } else {
    return ua.indexOf(browser) > -1;
  }
}

const csv = {
  _isIE11() {
    let iev = 0;
    const ieold = (/MSIE (\d+\.\d+);/.test(navigator.userAgent));
    const trident = !!navigator.userAgent.match(/Trident\/7.0/);
    const rv = navigator.userAgent.indexOf('rv:11.0');

    if (ieold) {
      iev = Number(RegExp.$1);
    }
    if (navigator.appVersion.indexOf('MSIE 10') !== -1) {
      iev = 10;
    }
    if (trident && rv !== -1) {
      iev = 11;
    }

    return iev === 11;
  },

  _isEdge() {
    return /Edge/.test(navigator.userAgent);
  },

  _getDownloadUrl(text) {
    const BOM = '\uFEFF';
    // Add BOM to text for open in excel correctly
    if (window.Blob && window.URL && window.URL.createObjectURL) {
      const csvData = new Blob([BOM + text], { type: 'text/csv' });
      return URL.createObjectURL(csvData);
    } else {
      return 'data:attachment/csv;charset=utf-8,' + BOM + encodeURIComponent(text);
    }
  },

  download(filename, text) {
    if (has('ie') && has('ie') < 10) {
      // has module unable identify ie11 and Edge
      const oWin = window.top.open('about:blank', '_blank');
      oWin.document.charset = 'utf-8';
      oWin.document.write(text);
      oWin.document.close();
      oWin.document.execCommand('SaveAs', filename);
      oWin.close();
    } else if (has('ie') === 10 || this._isIE11() || this._isEdge()) {
      const BOM = '\uFEFF';
      const csvData = new Blob([BOM + text], { type: 'text/csv' });
      navigator.msSaveBlob(csvData, filename);
    } else {
      const link = document.createElement('a');
      link.download = filename;
      link.href = this._getDownloadUrl(text);
      document.body.appendChild(link);
      link.click();
      document.body.removeChild(link);
    }
  }
};

export default csv;