zarm-mobile/lib/Picker/utils.js

UI for react.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

exports.formatFn = formatFn;
exports.isChildrenEqual = isChildrenEqual;
exports.arrayTreeFilter = arrayTreeFilter;
exports.formatToInit = formatToInit;
exports.formatBackToObject = formatBackToObject;

function getFormatter(type) {
  var formatter = void 0;
  if (type === 'year') {
    formatter = 'YYYY[年]';
  } else if (type === 'month') {
    formatter = 'YYYY-MM';
  } else if (type === 'time') {
    formatter = 'HH:mm';
  } else if (type === 'datetime') {
    formatter = 'YYYY-MM-DD HH:mm';
  } else {
    formatter = 'YYYY-MM-DD';
  }
  return formatter;
}

function isEmptyArray(a) {
  return !a || !a.length;
}

function formatFn(instance, value) {
  var format = instance.props.format;

  var type = typeof format === 'undefined' ? 'undefined' : _typeof(format);

  if (type === 'string') {
    return value.format(format);
  }

  if (type === 'function') {
    return format(value);
  }

  return value.format(getFormatter(instance.props.mode));
}

function isChildrenEqual(c1, c2, pure) {
  if (isEmptyArray(c1) && isEmptyArray(c2)) {
    return true;
  }
  if (pure) {
    return c1 === c2;
  }
  if (c1.length !== c2.length) {
    return false;
  }
  var len = c1.length;
  for (var i = 0; i < len; i += 1) {
    if (c1[i].value !== c2[i].value || c1[i].label !== c2[i].label) {
      return false;
    }
  }
  return true;
}

function arrayTreeFilter(data, filterFn, options) {
  options = options || {};
  options.childrenKeyName = options.childrenKeyName || 'children';
  var children = data || [];
  var result = [];
  var level = 0;

  var filterInnerFn = function filterInnerFn(item) {
    return filterFn(item, level);
  };

  do {
    var foundItem = children.filter(filterInnerFn)[0];
    if (!foundItem) {
      break;
    }
    result.push(foundItem);
    children = foundItem[options.childrenKeyName] || [];
    level += 1;
  } while (children.length > 0);
  return result;
}

function formatToInit(data, member, cols) {
  var _data = data || [];
  var result = [];
  var level = 0;

  while (_data) {
    var foundValue = _data[member];

    if (!foundValue) {
      break;
    }

    if (cols && level >= cols) {
      break;
    }

    result.push(foundValue);
    if (Object.prototype.hasOwnProperty.call(_data, 'children')) {
      _data = _data.children[0];
    } else {
      break;
    }
    level += 1;
  }

  return result;
}

var filterValue = function filterValue(dataSource, value, member, level) {
  return dataSource.filter(function (item) {
    return item[member] === value[level];
  })[0];
};

function formatBackToObject(data, value, cascade, member, cols) {
  if (!cascade) {
    var _result = data.map(function (item, index) {
      return item.filter(function (itemInner) {
        return itemInner[member] === value[index];
      })[0];
    });
    return value.length === 1 ? _result[0] : _result;
  }

  var _data = data || [];
  var result = [];
  var level = 0;

  while (_data) {
    var curValue = filterValue(_data, value, member, level);
    if (!curValue) {
      break;
    }

    if (cols && level >= cols) {
      break;
    }

    result.push(curValue);
    if (Object.prototype.hasOwnProperty.call(curValue, 'children')) {
      _data = curValue.children;
    } else {
      break;
    }
    level += 1;
  }
  return result;
}