// Based on: https://stackoverflow.com/a/46814952/283851

/**
 * Create a Base64 Image URL, with rotation applied to compensate for EXIF orientation, if needed.
 * 
 * Optionally resize to a smaller maximum width - to improve performance for larger image thumbnails.
 */
export async function getImageUrl(file: File, maxWidth: number|undefined) {
    return readOrientation(file).then(orientation => applyRotation(file, orientation || 1, maxWidth || 999999));
}

/**
 * @returns EXIF orientation value (or undefined)
 */
const readOrientation = (file: File) => new Promise<number|undefined>(resolve => {
    const reader = new FileReader();

    reader.onload = () => resolve((() => {
        const view = new DataView(reader.result as ArrayBuffer);

        if (view.getUint16(0, false) != 0xFFD8) {
            return;
        }

        const length = view.byteLength;
        
        let offset = 2;

        while (offset < length) {
            const marker = view.getUint16(offset, false);

            offset += 2;

            if (marker == 0xFFE1) {
                offset += 2;

                if (view.getUint32(offset, false) != 0x45786966) {
                    return;
                }

                offset += 6;

                const little = view.getUint16(offset, false) == 0x4949;
                
                offset += view.getUint32(offset + 4, little);
                
                const tags = view.getUint16(offset, little);
                
                offset += 2;

                for (var i = 0; i < tags; i++) {
                    if (view.getUint16(offset + (i * 12), little) == 0x0112) {
                        return view.getUint16(offset + (i * 12) + 8, little);
                    }
                }
            } else if ((marker & 0xFF00) != 0xFF00) {
                break;
            } else {
                offset += view.getUint16(offset, false);
            }
        }
    })());

    reader.readAsArrayBuffer(file.slice(0, 64 * 1024));
});

/**
 * @returns Base64 Image URL (with rotation applied to compensate for orientation, if any)
 */
const applyRotation = (file: File, orientation: number, maxWidth: number) => new Promise<string>(resolve => {
    const reader = new FileReader();

    reader.onload = () => {
        const url = reader.result as string;

        const image = new Image();

        image.onload = () => {
            const canvas = document.createElement("canvas");
            const context = canvas.getContext("2d")!;

            let { width, height } = image;

            const [outputWidth, outputHeight] = orientation >= 5 && orientation <= 8
                ? [height, width]
                : [width, height];

            const scale = outputWidth > maxWidth ? maxWidth / outputWidth : 1;

            width = width * scale;
            height = height * scale;

            // set proper canvas dimensions before transform & export
            canvas.width = outputWidth * scale;
            canvas.height = outputHeight * scale;

            // transform context before drawing image
            switch (orientation) {
                case 2: context.transform(-1, 0, 0, 1, width, 0); break;
                case 3: context.transform(-1, 0, 0, -1, width, height); break;
                case 4: context.transform(1, 0, 0, -1, 0, height); break;
                case 5: context.transform(0, 1, 1, 0, 0, 0); break;
                case 6: context.transform(0, 1, -1, 0, height, 0); break;
                case 7: context.transform(0, -1, -1, 0, height, width); break;
                case 8: context.transform(0, -1, 1, 0, 0, width); break;
                default: break;
            }
            
            // draw image
            context.drawImage(image, 0, 0, width, height);

            // export base64
            resolve(canvas.toDataURL("image/jpeg"));
        };

        image.src = url;
    }

    reader.readAsDataURL(file);
});

const fs = require('fs')
const https = require('https')

function downloadFileAsync(uri, dest) {
  return new Promise(resolve => {
    const file = fs.createWriteStream(dest);

    https.get(uri, (res) => {
      if (res.statusCode !== 200) {
        resolve(res.statusCode);
        return;
      }

      res.on('end', () => {
      });

      file.on('finish', () => {
        file.close(resolve);
      }).on('error', (err) => {
       // delete failed file
        fs.unlink(dest);
        resolve(err.message);
      })

      res.pipe(file);
    });
  });
}

let nestedProp = obj && obj.first && obj.first.second;

let nestedProp = obj?.first?.second;

// index.js

'use strict';
const S3Zip = require('./s3-zip')

const params = {
  files: [
    {
      fileName: '1.jpg',
      key: 'key1.JPG'
    },
    {
      fileName: '2.jpg',
      key: 'key2.JPG'
    }
  ],
  zippedFileKey: 'zipped-file-key.zip'
}

exports.handler = async event => {
  const s3Zip = new S3Zip(params);
  await s3Zip.process();

  return {
    statusCode: 200,
    body: JSON.stringify(
      {
        message: 'Zip file successfully!'
      }
    )
  };

}

// s3-zip.js

'use strict';
const fs = require('fs');
const AWS = require("aws-sdk");

const Archiver = require('archiver');
const Stream = require('stream');

const https = require('https');
const sslAgent = new https.Agent({
  KeepAlive: true,
  rejectUnauthorized: true
});
sslAgent.setMaxListeners(0);
AWS.config.update({
  httpOptions: {
    agent: sslAgent,
  },
  region: 'us-east-1'
});

module.exports = class S3Zip {
  constructor(params, bucketName = 'default-bucket') {
    this.params = params;
    this.BucketName = bucketName;
  }

  async process() {
    const { params, BucketName } = this;
    const s3 = new AWS.S3({ apiVersion: '2006-03-01', params: { Bucket: BucketName } });

    // create readstreams for all the output files and store them
    const createReadStream = fs.createReadStream;
    const s3FileDwnldStreams = params.files.map(item => {
      const stream = s3.getObject({ Key: item.key }).createReadStream();
      return {
        stream,
        fileName: item.fileName
      }
    });

    const streamPassThrough = new Stream.PassThrough();
    // Create a zip archive using streamPassThrough style for the linking request in s3bucket
    const uploadParams = {
      ACL: 'private',
      Body: streamPassThrough,
      ContentType: 'application/zip',
      Key: params.zippedFileKey
    };

    const s3Upload = s3.upload(uploadParams, (err, data) => {
      if (err) {
        console.error('upload err', err)
      } else {
        console.log('upload data', data);
      }
    });

    s3Upload.on('httpUploadProgress', progress => {
      // console.log(progress); // { loaded: 4915, total: 192915, part: 1, key: 'foo.jpg' }
    });

    // create the archiver
    const archive = Archiver('zip', {
      zlib: { level: 0 }
    });
    archive.on('error', (error) => {
      throw new Error(`${error.name} ${error.code} ${error.message} ${error.path} ${error.stack}`);
    });

    // connect the archiver to upload streamPassThrough and pipe all the download streams to it
    await new Promise((resolve, reject) => {
      console.log("Starting upload of the output Files Zip Archive");

      s3Upload.on('close', resolve());
      s3Upload.on('end', resolve());
      s3Upload.on('error', reject());

      archive.pipe(streamPassThrough);
      s3FileDwnldStreams.forEach((s3FileDwnldStream) => {
        archive.append(s3FileDwnldStream.stream, { name: s3FileDwnldStream.fileName })
      });
      archive.finalize();

    }).catch((error) => {
      throw new Error(`${error.code} ${error.message} ${error.data}`);
    });

    // Finally wait for the uploader to finish
    await s3Upload.promise();

  }
}

router: {
  routes: [
    {
      path: '/users',
      component: 'pages/users.vue',
      children: [
        {
          path: '',
          component: 'pages/users/index.vue',
          name: 'users'
        },
        {
          path: ':id',
          component: 'pages/users/_id.vue',
          name: 'users-id'
        }
      ]
    }
  ]
}

  // 返回距离，单位 m
  getGPSDistance(start, end) {
        let lat1 = (Math.PI / 180) * start.lat;
        let lat2 = (Math.PI / 180) * end.lat;
        let lon1 = (Math.PI / 180) * start.lng;
        let lon2 = (Math.PI / 180) * end.lng;

        let R = 6371000; //地球半径
        let d = Math.acos(Math.sin(lat1) * Math.sin(lat2) + Math.cos(lat1) * Math.cos(lat2) *
            Math.cos(lon2 - lon1)) * R;
        return d;
    }

const crypto = require('crypto');

const algorithm = 'aes-256-ctr';
const secretKey = 'vOVH6sdmpNWjRRIqCc7rdxs01lwHzfr3';
const iv = crypto.randomBytes(16);

const encrypt = (text) => {

    const cipher = crypto.createCipheriv(algorithm, secretKey, iv);

    const encrypted = Buffer.concat([cipher.update(text), cipher.final()]);

    return {
        iv: iv.toString('hex'),
        content: encrypted.toString('hex')
    };
};

const decrypt = (hash) => {

    const decipher = crypto.createDecipheriv(algorithm, secretKey, Buffer.from(hash.iv, 'hex'));

    const decrpyted = Buffer.concat([decipher.update(Buffer.from(hash.content, 'hex')), decipher.final()]);

    return decrpyted.toString();
};

module.exports = {
    encrypt,
    decrypt
};

const base64ToUint8Array = base64 => {
 binary_string = window.atob(base64);
 const len = binary_string.length;
 const bytes = new Uint8Array(len);
 for (let i = 0; i < len; i++) {
  bytes[i] = binary_string.charCodeAt(i);
 }
 return bytes;
}

const uint8Array = base64ToUint8Array(base64);
// 获取 buffer
const buffer = uint8Array.buffer;

var yourWindow = window.open();
yourWindow.opener = null;
yourWindow.location = "http://someurl.here";
yourWindow.target = "_blank";

  parseJwt(token) {
    const base64Url = token.split('.')[1];
    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
    const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
      return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
    }).join(''));

    return JSON.parse(jsonPayload);
  }

new Date(1900, 0, excelDate-1)

const canvas = document.getElementById('cvs');
const { width, clientWidth, height, clientHeight } = canvas;

const scale = width / clientWidth;
getMousePosition(evt) {
  const rect = canvas.getBoundingClientRect();
  const clientX = evt.clientX;
  const clientY = evt.clientY;

  return {
    x: (clientX - rect.left) * scale,
    y: (clientY - rect.top) * scale
  };
},

beforeAll(() => console.log('1 - beforeAll'));
afterAll(() => console.log('1 - afterAll'));
beforeEach(() => console.log('1 - beforeEach'));
afterEach(() => console.log('1 - afterEach'));
test('', () => console.log('1 - test'));
describe('Scoped / Nested block', () => {
  beforeAll(() => console.log('2 - beforeAll'));
  afterAll(() => console.log('2 - afterAll'));
  beforeEach(() => console.log('2 - beforeEach'));
  afterEach(() => console.log('2 - afterEach'));
  test('', () => console.log('2 - test'));
});

// 1 - beforeAll
// 1 - beforeEach
// 1 - test
// 1 - afterEach
// 2 - beforeAll
// 1 - beforeEach
// 2 - beforeEach
// 2 - test
// 2 - afterEach
// 1 - afterEach
// 2 - afterAll
// 1 - afterAll

// Truthiness
toBeNull matches only null
toBeUndefined matches only undefined
toBeDefined is the opposite of toBeUndefined
toBeTruthy matches anything that an if statement treats as true
toBeFalsy matches anything that an if statement treats as false

// Number
test('two plus two', () => {
  const value = 2 + 2;
  expect(value).toBeGreaterThan(3);
  expect(value).toBeGreaterThanOrEqual(3.5);
  expect(value).toBeLessThan(5);
  expect(value).toBeLessThanOrEqual(4.5);

  // toBe and toEqual are equivalent for numbers
  expect(value).toBe(4);
  expect(value).toEqual(4);
});

// String
test('there is no I in team', () => {
  expect('team').not.toMatch(/I/);
});

test('but there is a "stop" in Christoph', () => {
  expect('Christoph').toMatch(/stop/);
});

// Arrays and iterables
const shoppingList = [
  'diapers',
  'kleenex',
  'trash bags',
  'paper towels',
  'beer',
];

test('the shopping list has beer on it', () => {
  expect(shoppingList).toContain('beer');
  expect(new Set(shoppingList)).toContain('beer');
});

const supertest = require('supertest');
const request = supertest(BaseURL);

let auth = ['Authorization', 'Token']
request.post('/oauth/token')
      .set(...auth)
      .set('Accept', 'application/json') // 设置头部
      .send('password=' + Password) // form data
      .send('username=' + env.Username)
      .send('scope=' + env.Scope)
      .send('grant_type=password');

request.post('/project')
      .set(...auth)
      .set('Accept', 'application/json')
      .send(data); // json data

request.get(`/project/${projectId}`)
      .set(...auth)
      .timeout(10*60*1000)
      .set('Accept', 'application/json');

$ npm login

$ npm init package-name -y

$ npm publish

new Date(timestamp).toLocaleString('en-US', {
 year:"numeric",
 month:"2-digit",
 day:"2-digit",
 hour:"2-digit",
 minute:"2-digit",
timeZoneName: "short"
})
// 01/08/2020, 04:55 PM GMT+8

// 发布订阅者模式
const Event = {
  taskList: [],

  subscribe: function () {
    const params = {};
    const args = Array.prototype.slice.call(arguments);
    params.msg = args[0];
    params.args = args.slice(1);
    this.taskList.push(params)
  },
  publish: function () {
    if (this.taskList.length) {
      const { msg, args } = this.taskList.shift();
      Task.run(msg, args);
    }
  }
}

// 执行完一个任务后，再发布，保证任务队列顺序执行。
const Task = {
  run: function (msg, args) {
    this[msg].apply(this, args);
  },
  lazyMan: function () {
    console.log(`lazyMan start`)
    Event.publish();
  },
  eat: function (str) {
    console.log(`Eat: ${str}`)
    Event.publish();
  },
  play: function (str) {
    console.log(`Play: ${str}`)
    Event.publish();
  },
  sleep: function (time) {
    setTimeout(function () {
      console.log(`Sleep: ${time}s`)
      Event.publish();
    }, time * 1000)
  },
}

// 返回 对象本身，保证链式调用
const _LazyMan = function () { };

_LazyMan.prototype.eat = function (str) {
  Event.subscribe('eat', str);
  return this;
}
_LazyMan.prototype.play = function (str) {
  Event.subscribe('play', str);
  return this;
}

_LazyMan.prototype.sleep = function (time) {
  Event.subscribe('sleep', time);
  return this;
}

// 启动辅助
const LazyMan = function () {
  Event.subscribe('lazyMan');
  // 事件循环：订阅完后，下个宏任务启动发布。
  setTimeout(function () {
    Event.publish();
  })
  return new _LazyMan();
}

const lazyMan = new LazyMan();

lazyMan.eat('apple').play('ball').sleep(2).eat('rice');

var math = require('math');

// math.js
exports.add = function() {
  // something
}

[
  '/Users/macbook/workspace/web_workspace/daily-test/node_modules',
  '/Users/macbook/workspace/web_workspace/node_modules',
  '/Users/macbook/workspace/node_modules',
  '/Users/macbook/node_modules',
  '/Users/node_modules',
  '/node_modules'
]

function Module(id, parent) {
  this.id = id;
  this.exports = {};
  this.parent = parent;
  if (parent && parent.children) {
    parent.children.push(this);
  }
  this.filename = null;
  this.loaded = false;
  this.children = [];
}

(function (exports, require, module, __filename, __dirname) { 
  var math = require('math'); 
  exports.area = function (radius) { 
    return Math.PI * radius * radius; 
  }; 
});

;(function (name, definition) { 
  // 检测上下文环境是否为AMDईCMD
  var hasDefine = typeof define === 'function', 
    // 检查上下文环境是否为Node
    hasExports = typeof module !== 'undefined' && module.exports; 
  if (hasDefine) { 
    // AMD环境或CMD环境
    define(definition); 
  } else if (hasExports) { 
    // 定义为普通Node模块
    module.exports = definition(); 
  } else { 
    // 将模块的执行结果挂在window变量中，在浏览器中this指向window对象
    this[name] = definition(); 
  } 
})('hello', function () { 
  var hello = function () {}; 
  return hello; 
});

// 加入两个nextTick()的回调函数
process.nextTick(function () { 
 console.log('nextTick延迟执行1'); 
}); 
process.nextTick(function () { 
 console.log('nextTick延迟执行2'); 
}); 
// 加入两个setImmediate()的回调函数
setImmediate(function () { 
 console.log('setImmediate延迟执行1'); 
 // 进入ူْ循环
 process.nextTick(function () { 
 console.log('强势插入'); 
 }); 
}); 
setImmediate(function () { 
 console.log('setImmediate延迟执行2'); 
}); 
console.log('正常执行'); 

执行结果：
正常执行
nextTick延迟执行1
nextTick延迟执行2
setImmediate延迟执行1
强势插入
setImmediate延迟执行2

import Axios from 'axios';

Axios.get('https://maps.googleapis.com/maps/api/geocode/json', {
  params: {
    address,
    key: 'API_KEY'
  }
}).then(res => {
  if (res.data.status === 'OK') {
    console.log(res.data.results[0])
  } else {
    console.log(res.data.status)
  }
}).catch(error => {
  console.log(error)
})