/**
 * 快速排序
 * @param arr
 */
function quickSort(arr) {
  var middle = arr[Math.floor(arr.length / 2)];
  var beforeArr = [];
  var afterArr = [];
  var middleArr = [];
  // 分
  for (var i = 0, len = arr.length; i < len; i++) {
    if (arr[i] === middle) {
      middleArr.push(arr[i]);
    } else if (arr[i] < middle) {
      beforeArr.push(arr[i]);
    } else {
      afterArr.push(arr[i]);
    }
  }
  // 分 End
  if (beforeArr.length > 1) {
    beforeArr = quickSort(beforeArr);
  }
  if (afterArr.length > 1) {
    afterArr = quickSort(afterArr);
  }
  return [...beforeArr, ...middleArr, ...afterArr];
}

/**
 * 冒泡排序
 * @param arr
 */
function bubbleSort(arr) {
  const resultArr = arr.slice(0);
  for (var i = 0, len = resultArr.length; i < len; i++) {
    for (var j = 0; j < len - i - 1; j++) {
      if (resultArr[j] > resultArr[j + 1]) {
        // 交换
        var temp = resultArr[j];
        resultArr[j] = resultArr[j + 1];
        resultArr[j + 1] = temp;
      }
    }
  }
  return resultArr;
}

/**
 * 选择排序
 * @param arr
 */
function selectSort(arr) {
  var resultArr = arr.slice(0);
  for (var i = 0, len = resultArr.length; i < len; i++) {
    var minIdx = i;
    for (var j = i + 1; j < len; j++) {
      if (resultArr[j] < resultArr[minIdx]) {
        minIdx = j;
      }
    }
    // 交换
    var temp = resultArr[i];
    resultArr[i] = resultArr[minIdx];
    resultArr[minIdx] = temp;
    // 装逼写法，实际性能差
    // [resultArr[i], resultArr[minIdx]] = [resultArr[minIdx], resultArr[i]];
  }
  return resultArr;
}

/**
 * 插入排序
 * @param arr
 */
function insertionSort(arr) {
  var resultArr = arr.slice(0);
  // 想想打扑克的时候，没摸一张牌，都根据大小插入到手中已有的牌中
  for (var i = 1, len = resultArr.length; i < len; i++) {
    // 摸牌
    var card = resultArr[i];
    var j = i - 1;
    // 从右往左，看手里的牌，如果比刚摸的牌大，就腾位置
    while (j >= 0 && resultArr[j] > card) {
      resultArr[j + 1] = resultArr[j];
      j--;
    }
    // 放牌
    resultArr[j + 1] = card;
  }
  return resultArr;
}

/**
 * 归并排序
 * @param arr
 */
function mergeSort(arr) {
  var splitIdx = Math.floor(arr.length / 2);
  var beforeArr = arr.slice(0, splitIdx);
  var afterArr = arr.slice(splitIdx);
  if (beforeArr.length > 1) {
    beforeArr = mergeSort(beforeArr);
  }
  if (afterArr.length > 1) {
    afterArr = mergeSort(afterArr);
  }
  var resultArr = [];
  var beforeIdx = 0,
    afterIdx = 0;
  while (beforeIdx < beforeArr.length || afterIdx < afterArr.length) {
    // 前后都有
    if (beforeIdx < beforeArr.length && afterIdx < afterArr.length) {
      if (beforeArr[beforeIdx] < afterArr[afterIdx]) {
        resultArr.push(beforeArr[beforeIdx]);
        beforeIdx++;
      } else {
        resultArr.push(afterArr[afterIdx]);
        afterIdx++;
      }
    } else if (beforeIdx < beforeArr.length) {
      // 前还有
      resultArr.push(beforeArr[beforeIdx]);
      beforeIdx++;
    } else {
      resultArr.push(afterArr[afterIdx]);
      afterIdx++;
    }
  }
  return resultArr;
}

// Prepare
var ARRAY_LENGTH = 10000;
var MAX_VALUE = ARRAY_LENGTH * 10;
var arr = new Array(ARRAY_LENGTH).fill(0).map(x => Math.floor(Math.random() * MAX_VALUE));
console.log('original array', arr);

// Test quick sort
console.time('quick sort');
console.log('after quick sort', quickSort(arr));
console.timeEnd('quick sort');

// Test bulle sort
console.time('bulle sort');
console.log('after bulle sort', bubbleSort(arr));
console.timeEnd('bulle sort');

// Test select sort
console.time('select sort');
console.log('after select sort', bubbleSort(arr));
console.timeEnd('select sort');

// Test insertion sort
console.time('insertion sort');
console.log('after insertion sort', insertionSort(arr));
console.timeEnd('insertion sort');

// Test merge sort
console.time('merge sort');
console.log('after merge sort', mergeSort(arr));
console.timeEnd('merge sort');

class SQLiteClient {
  constructor(db) {
    this.db = db;
  }

  beginTransaction() {
    return this._exec('BEGIN TRANSACTION;');
  }

  commitTransaction() {
    return this._exec('COMMIT TRANSACTION;');
  }

  rollbackTransaction() {
    return this._exec('ROLLBACK TRANSACTION;');
  }

  executeQuery(sql, params) {
    return this._execute('all', sql, params);
  }

  executeNonQuery(sql, params) {
    return this._execute('run', sql, params)
      .then(result => {
        return result.changes;
      });
  }

  executeScalar(sql, params) {
    return this._execute('get', sql, params);
  }

  executeInsert(sql, params) {
    return this._execute('run', sql, params)
      .then(result => {
        return result.lastID;
      });
  }

  _execute(type, sql, params) {
    if (!sql) {
      throw new Error('SQL not found.');
    }
    return new Promise((resolve, reject) => {
      // Process dynamic sql param
      sql = sql.replace(/#[a-zA-Z0-9]+/g, (match, offset, source) => {
        return params[match.slice(1)] || '';
      });
      // Not allow surplus parameters, Need get the used parameter keys
      let sqlNeedParamKeys = (sql.match(/@[a-zA-Z0-9]+/g) || []).map(x => x.slice(1));
      params = params || {};
      let sqlParams = {};
      // Process parameters
      sqlNeedParamKeys.forEach(k => {
        sqlParams[`@${k}`] = params[k];
      });

      this.db[type](sql, sqlParams, function (err, row) {
        if (err) { return reject(err) }
        if (type === 'run') {
          row = {
            lastID: this.lastID,
            changes: this.changes
          };
        }
        resolve(row);
      });
    });
  }

  // Execute sql
  _exec(sql) {
    return new Promise((resolve, reject) => {
      this.db.exec(sql, (err, row) => {
        if (err) { return reject(err) }
        resolve();
      });
    });
  }
}

module.exports = SQLiteClient;

function removeDuplicates(nums) {
  if (!nums || nums.length === 0) {
    return 0;
  }
  let len = nums.length;
  let currentLen = 1;
  let current = nums[0];
  for (var i = 1; i < len; i++) {
    if (nums[i] !== current) {
      currentLen += 1;
      current = nums[i];
      nums[currentLen - 1] = nums[i];
    }
  }
  nums.length = currentLen;
  return currentLen;
}

var nums = [1, 1, 2];
console.log(nums, removeDuplicates(nums));
nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
console.log(nums, removeDuplicates(nums));

var SSH = require('simple-ssh');
var argv = require('yargs').argv;

var ssh = new SSH({
  host: '11.11.11.11',
  user: 'root',
  pass: 'xxx',
  baseDir: '/opt/docker-builds/'
});

var opt = {
  out: function (stdout) {
    console.log(stdout);
  },
  err: function (stderr) {
    console.error(stderr);
  }
};

var out = function (stdout) {
  console.log(stdout);
}

const name = argv.name || argv.n;
const version = argv.version || argv.v;

if(!name || !version){
  return console.error('must provide --name(-n) and --version(-v)');
}

const projectFolder = name;
const projectName = `jay/${name}`;
const versionNo = version;

ssh.exec(`docker build -t ${projectName}:${versionNo} ${projectFolder}`, opt)
  //.exec(`docker push xxx.com/${projectName}:${versionNo}`, opt) // 没有仓库需要注销
  .start();

function lengthOfLongestSubstring(text) {
  function hasRepeatChar(str) {
    var strArr = str.split('');
    var obj = {};
    strArr.forEach(x => (obj[x] = true));
    return strArr.length != Object.keys(obj).length;
  }

  var longStr = '';
  var len = text.length;
  var tempStr = '';
  for (var i = 0; i < len - longStr.length; i++) {
    tempStr = text[i];
    for (var j = i + 1; j < len; j++) {
      if (hasRepeatChar(tempStr + text[j])) {
        if (longStr.length < tempStr.length) {
          longStr = tempStr;
        }
        break;
      } else {
        tempStr += text[j];
      }
    }
    if (!hasRepeatChar(tempStr)) {
      if (longStr.length < tempStr.length) {
        longStr = tempStr;
      }
    }
  }
  // console.log(longStr);
  return longStr.length;
}
var len;
len = lengthOfLongestSubstring('abcdefghijklmn');
console.log(len, len === 14);
len = lengthOfLongestSubstring('cbca');
console.log(len, len === 3);
len = lengthOfLongestSubstring('c');
console.log(len, len === 1);

const Hello = props => <View><Text>Hello</Text></View>;
// Not working
<TouchableWithoutFeedback onPress={()=>alert('working')}>
  <Hello />
</TouchableWithoutFeedback>

// Working
<TouchableWithoutFeedback onPress={()=>alert('working')}>
  <View>
    <Hello />
  </View>
</TouchableWithoutFeedback>

class Map {
  constructor() {
    this.$keyObj = {};
    this.$valueObj = {};
    this.$length = 0;
  }
  set(key, value) {
    const autoKey = `key${Map.idx++}`;   
    this.$keyObj[autoKey] = key;
    this.$valueObj[autoKey] = value;
    // 需要判断是否覆盖来控制 $length
  }
  _getAutoKey(key) {
    const keyItem = Object.entries(this.$keyObj).find(x => x[1] === key);
    return keyItem[0];
  }
  get(key) {
    const autoKey = this._getAutoKey(key);
    if (!autoKey) {
      return undefined;
    }
    return this.$valueObj[autoKey];
  }
}

Map.idx = 1;

// Usage

var map = new Map();
var key = new Object();
map.set(key, 1);
console.log(map.get(key), map.get(key) === 1);

const fs = require('fs');
const path = require('path');
const http = require('http');
const util = require('util');

const MIME_MAP = {
  '.js': 'text/javascript',
  '.css': 'text/css',
};

const WEB_ROOT = path.join(__dirname, 'webroot');

const server = http.createServer((req, res) => {
  const { url } = req;
  let fileUrl = '';
  if (/\.[a-zA-Z0-9]+$/.test(url)) {
    fileUrl = path.join(WEB_ROOT, url);
  } else {
    fileUrl = path.join(WEB_ROOT, 'index.html');
  }
  util
    .promisify(fs.exists)(fileUrl)
    .then(isExists => {
      if (!isExists) {
        res.write('404');
        return res.end();
      }
      const extName = path.extname(fileUrl);
      const mimeType = MIME_MAP[String(extName).toLowerCase()];
      if (mimeType) {
        res.writeHead(200, { 'content-type': mimeType });
      }
      fs.createReadStream(fileUrl).pipe(res);
    });
});

server
  .listen(80, () => {
    const addr = server.address();
    console.info('server started...', addr);
  })
  .on('error', console.error);

class MysqlClient {
  constructor(pool) {
    this.pool = pool;
  }

  /**
   * Begin database transaction
   */
  beginTransaction() {
    return this._getConnection()
      .then(conn => {
        return new Promise((resolve, reject) => {
          conn.beginTransaction(err => {
            if (err) { return reject(err); }
            conn.inTransaction = true;
            resolve(conn);
          })
        });
      });
  }

  /**
   * Commit transaction
   * @param {any} conn 
   */
  commitTransaction(conn) {
    return new Promise((resolve, reject) => {
      conn.commit(err => {
        if (err) {
          conn.rollback(() => {
            this._releaseConnection(conn, true);
            reject(err);
          });
        } else {
          this._releaseConnection(conn, true);
          resolve();
        }
      });
    });
  }

  /**
   * Rollback transaction
   * @param {any} conn 
   */
  rollbackTransaction(conn) {
    return new Promise((resolve, reject) => {
      conn.rollback(() => {
        this._releaseConnection(conn, true);
        resolve();
      });
    });
  }

  /**
   * Get a database connection
   */
  getConnection() {
    return this._getConnection();
  }

  /**
   * Execute sql, return query result(array)
   * @param {string} sqlString 
   * @param {object | array} values 
   * @param {any} conn 
   */
  executeQuery(sqlString, values, conn = null) {
    return this._execute(sqlString, values, conn);
  }

  /**
   * Execute sql, return single result(the first one)
   * @param {string} sqlString 
   * @param {object | array} values 
   * @param {any} conn 
   */
  executeScalar(sqlString, values, conn = null) {
    return this._execute(sqlString, values, conn)
      .then(results => {
        if (results.length === 0) {
          return null;
        }
        return results[0];
      });
  }

  /**
   * Execute sql, return affected rows
   * @param {string} sqlString 
   * @param {object | array} values 
   * @param {any} conn 
   */
  executeNonQuery(sqlString, values, conn = null) {
    return this._execute(sqlString, values, conn)
      .then(results => {
        return results.affectedRows;
      });
  }

  /**
   * Execute sql, return insertId(for auto id)
   * @param {string} sqlString 
   * @param {object | array} values 
   * @param {any} conn 
   */
  executeInsert(sqlString, values, conn = null) {
    return this._execute(sqlString, values, conn)
      .then(results => {
        return results.insertId;
      });
  }

  /**
 * private function, get db connection
 */
  _getConnection() {
    return new Promise((resolve, reject) => {
      this.pool.getConnection((err, conn) => {
        if (err) { return reject(err); }
        resolve(conn);
      });
    });
  }

  /**
   * Release connection
   * @param {any} conn 
   * @param {boolean} closeTran 
   */
  _releaseConnection(conn, closeTran = false) {
    if (closeTran) {
      conn.inTransaction = false;
    }
    conn.release();
  }

  /**
   * Execute sql, return resuluts;
   * @param {string} sqlString 
   * @param {object|array} values 
   * @param {any} conn 
   */
  _execute(sqlString, values, conn) {
    let { sql, params } = this._processSqlAndParameter(sqlString, values);
    let p = conn ? Promise.resolve(conn) : this._getConnection();
    return p.then(conn => {
      return new Promise((resolve, reject) => {
        conn.query(sql, params, (err, results, fields) => {
          // If conn is in transaction, not release
          if (!conn.inTransaction) {
            this._releaseConnection(conn);
          }
          if (err) { return reject(err); }
          resolve(results);
        });
      });
    });
  }

  _processSqlAndParameter(sqlString, params) {
    let result;
    // If is an array, direct return.
    if (Array.isArray(params)) {
      result = {
        sql: sqlString,
        params: params.slice()
      };
    } else {
      // Replace object to array, and use ? replace @Property
      let paramArr = [];
      if (params) {
        let paramKeys = Object.keys(params);
        sqlString = sqlString.replace(/@[a-zA-Z0-9]+/g, (match, offset, str) => {
          let matchKey = match.replace('@', '');
          if (paramKeys.indexOf(matchKey) >= 0) {
            paramArr.push(params[matchKey]);
            return '?';
          }
          return match;
        });
      }
      result = {
        sql: sqlString,
        params: paramArr
      };
    }
    return result;
  }
}

module.exports = MysqlClient;

import { connect } from 'react-redux';
import { combineReducers, createStore } from 'redux';

const reducerMap = {};

export const reduxHelper = {
  store: null, // 缓存全局store
  _isFunction(fn) {
    return typeof fn === 'function';
  },
  /**
   * 创建Reducer的辅助方法
   * @param {object} initialState  默认state
   * @param {*} reducerObj
   */
  createReducer(initialState, reducerObj) {
    return (state = initialState, action) => {
      console.log('action', action.type);
      const reducerFn = reducerObj[action.type];
      if (this._isFunction(reducerFn)) {
        return reducerFn.call(null, state, action.payload);
      }
      return state;
    };
  },

  /**
   * 创建页面
   * @param {*} pageState
   * @param {*} viewComponent
   */
  createPage(pageState, viewComponent) {
    const self = this;
    reducerMap[pageState.namespace] = this.createReducer(pageState.state, pageState.reducers);
    function mapStateToProps(state) {
      const mapState = {};
      // 绑定页面的state属性
      Object.keys(pageState.state || {}).forEach(k => (mapState[k] = (state[pageState.namespace] || {})[k]));

      // 绑定用户定义的state属性
      let newCalcState = {};
      if (self._isFunction(pageState.mapStateToProps)) {
        newCalcState = pageState.mapStateToProps(state[pageState.namespace], this.store);
      }
      return { ...mapState, ...newCalcState };
    }
    function mapDispatchToProps(dispatch) {
      const mapDispatch = {};
      Object.keys(pageState.actions || {}).forEach(k => {
        const actionFn = pageState.actions[k];
        if (self._isFunction(actionFn)) {
          mapDispatch[k] = () => {
            actionFn(dispatch);
          };
        } else {
          console.warn(`key [${k}] not a actions`);
        }
      });
      return mapDispatch;
    }
    this.store && this.store.replaceReducer(combineReducers(reducerMap));
    return connect(mapStateToProps, mapDispatchToProps)(viewComponent);
  },

  createStore() {
    function reducer(state = {}, action) {
      return state;
    }
    this.store = createStore(reducer); // combineReducers(reducerMap)
    window.AppState = this.store;
    return this.store;
  }
};

 "importSort": {
    ".js, .jsx, .es6, .es,": {
      "parser": "babylon",
      "style": "module-compact"
    },
    ".ts, .tsx": {
      "parser": "typescript",
      "style": "eslint",
      "options": {}
    }
  },