开发完成 es 版本

.babelrc

@@ -0,0 +1,3 @@
+{
+    "presets": ["es2015", "stage-2"]
+}

.gitignore

@@ -0,0 +1 @@
+node_modules

es.js

@@ -0,0 +1,226 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define("PlusMessageBundle", [], factory);
+	else if(typeof exports === 'object')
+		exports["PlusMessageBundle"] = factory();
+	else
+		root["PlusMessageBundle"] = factory();
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, {
+/******/ 				configurable: false,
+/******/ 				enumerable: true,
+/******/ 				get: getter
+/******/ 			});
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEmpty = exports.analyze = undefined;
+
+var _analyze = __webpack_require__(1);
+
+var _analyze2 = _interopRequireDefault(_analyze);
+
+var _isEmpty = __webpack_require__(3);
+
+var _isEmpty2 = _interopRequireDefault(_isEmpty);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.analyze = _analyze2.default;
+exports.isEmpty = _isEmpty2.default;
+
+exports.default = function (messageData, defaultMessage) {
+  var errors = messageData.errors;
+
+
+  if (errors && !(0, _isEmpty2.default)(errors)) {
+    return (0, _analyze2.default)(errors, defaultMessage);
+  }
+
+  return (0, _analyze2.default)(messageData, defaultMessage);
+};
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var _Message = __webpack_require__(2);
+
+var _Message2 = _interopRequireDefault(_Message);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (messageData) {
+  var defaultMessage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var message = messageData.message;
+
+
+  if (message) {
+    if (Array.isArray(message)) {
+      var _message = _slicedToArray(message, 1),
+          firstMessage = _message[0];
+
+      return new _Message2.default(firstMessage);
+    }
+
+    return new _Message2.default(message);
+  }
+
+  for (var key in messageData) {
+
+    if (Array.isArray(messageData[key])) {
+      var _messageData$key = _slicedToArray(messageData[key], 1),
+          _firstMessage = _messageData$key[0];
+
+      return new _Message2.default(_firstMessage, key);
+    }
+
+    return new _Message2.default(messageData[key], key);
+  }
+
+  return new _Message2.default(defaultMessage);
+};
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Message = function () {
+  function Message(message) {
+    var input = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+    _classCallCheck(this, Message);
+
+    this.message = message;
+    this.input = input;
+  }
+
+  _createClass(Message, [{
+    key: "getMesaage",
+    value: function getMesaage() {
+      return this.message;
+    }
+  }, {
+    key: "getInputKey",
+    value: function getInputKey() {
+      return this.input;
+    }
+  }]);
+
+  return Message;
+}();
+
+exports.default = Message;
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = function (data) {
+
+  for (var i in data) {
+    return false;
+  }
+
+  return true;
+};
+
+/***/ })
+/******/ ]);
+});

es/Message.js

@@ -0,0 +1,20 @@
+class Message {
+
+  message;
+  input;
+
+  constructor(message, input = null) {
+    this.message = message;
+    this.input = input;
+  }
+
+  getMesaage() {
+    return this.message;
+  }
+
+  getInputKey() {
+    return this.input;
+  }
+}
+
+export default Message;

es/analyze.js

@@ -0,0 +1,30 @@
+import Message from './Message';
+
+export default (messageData, defaultMessage = null) => {
+
+  const { message } = messageData;
+
+  if (message) {
+    if (Array.isArray(message)) {
+
+      const [ firstMessage ] = message;
+
+      return new Message(firstMessage);
+    }
+
+    return new Message(message);
+  }
+
+  for (let key in messageData) {
+
+    if (Array.isArray(messageData[key])) {
+      const [ firstMessage ] = messageData[key];
+
+      return new Message(firstMessage, key);
+    }
+
+    return new Message(messageData[key], key);
+  }
+
+  return new Message(defaultMessage);
+};

es/index.js

@@ -0,0 +1,14 @@
+import analyze from './analyze';
+import isEmpty from './utils/isEmpty';
+
+export { analyze, isEmpty };
+export default (messageData, defaultMessage) => {
+
+  const { errors } = messageData;
+
+  if (errors && ! isEmpty(errors)) {
+    return analyze(errors, defaultMessage);
+  }
+
+  return analyze(messageData, defaultMessage);
+};

es/index.test.js

@@ -0,0 +1,98 @@
+import PlusMessageBundle from './index';
+
+test('Test message: { message: "This is a message." }', () => {
+
+  const message = { message: 'This is a message.' };
+
+  expect(
+    PlusMessageBundle(message).getMesaage()
+  ).toBe(
+    message.message
+  );
+
+});
+
+test('Test message: { message: [ "This is a array message item." ] }', () => {
+
+  const message = 'This is a array message item.';
+  const data = { message: [ message ] };
+
+  expect(PlusMessageBundle(data).getMesaage()).toBe(message);
+
+});
+
+test('Test message: { key1, "This is a object message." }', () => {
+
+  const input = 'key1';
+  const message = 'This is a object message.';
+  const Messageable = PlusMessageBundle({
+    [input]: message
+  });
+
+  expect(Messageable.getMesaage()).toBe(message);
+  expect(Messageable.getInputKey()).toBe(input);
+
+});
+
+test('Test message: { key1, [ "This is a object message array item." ] }', () => {
+
+  const input = 'key1';
+  const message = 'This is a object message array item.';
+  const Messageable = PlusMessageBundle({
+    [input]: message
+  });
+
+  expect(Messageable.getMesaage()).toBe(message);
+  expect(Messageable.getInputKey()).toBe(input);
+
+});
+
+test(
+`Test message: 
+    {
+      "message": "This is a message.",
+      "errors": {
+        "key1": [ "This is a error message item." ]
+      }
+    }
+`,
+() => {
+
+  const input = 'key1';
+  const message = 'This is a error message item.';
+  const Messageable = PlusMessageBundle({
+    message: 'This is a message.',
+    errors: {
+      [input]: [ message ]
+    }
+  });
+
+  expect(Messageable.getMesaage()).toBe(message);
+  expect(Messageable.getInputKey()).toBe(input);
+
+});
+
+test(
+`Test message: 
+    {
+      "message": "This is a message.",
+      "errors": {
+        "key1": "This is a error message."
+      }
+    }
+`,
+() => {
+
+  const input = 'key1';
+  const message = 'This is a error message.';
+  const Messageable = PlusMessageBundle({
+    message: 'This is a message.',
+    errors: {
+      [input]: message
+    }
+  });
+
+  expect(Messageable.getMesaage()).toBe(message);
+  expect(Messageable.getInputKey()).toBe(input);
+
+});