node-switchbot 1.1.3-beta.0 → 1.1.3-beta.4

package/lib/parameter-checker.js

@@ -1,27 +1,25 @@
-'use strict';
-
 class ParameterChecker {
-  constructor() {
-    this._error = null;
-  }
-
-  get error() {
-    // ----------------------------------
-    // Error
-    // {
-    //   code: 'TYPE_INVALID',
-    //   message: 'The `age` must be an integer.'
-    //   name: 'age',
-    // } 
-    // ---------------------------------
-    return this._error;
-  }
-
-  isSpecified(value) {
-    return (value === void 0) ? false : true;
-  }
-
-  /* ------------------------------------------------------------------
+	constructor() {
+		this._error = null;
+	}
+
+	get error() {
+		// ----------------------------------
+		// Error
+		// {
+		//   code: 'TYPE_INVALID',
+		//   message: 'The `age` must be an integer.'
+		//   name: 'age',
+		// } 
+		// ---------------------------------
+		return this._error;
+	}
+
+	isSpecified(value) {
+		return (value === void 0) ? false : true;
+	}
+
+	/* ------------------------------------------------------------------
   * check(obj, rule, required)
   * - Check if the specified object contains valid values
   *
@@ -54,84 +52,84 @@ class ParameterChecker {
   *   throw new Error(message);
   * }
   * ---------------------------------------------------------------- */
-  check(obj, rules, required = false) {
-    this._error = null;
-    if (required) {
-      if (!this.isSpecified(obj)) {
-        this._error = {
-          code: 'MISSING_REQUIRED',
-          message: 'The first argument is missing.'
-        };
-        return false;
-      }
-    } else {
-      if (!obj) {
-        return true;
-      }
-    }
-
-    if (!this.isObject(obj)) {
-      this._error = {
-        code: 'MISSING_REQUIRED',
-        message: 'The first argument is missing.'
-      };
-      return false;
-    }
-
-    let result = true;
-    let name_list = Object.keys(rules);
-
-    for (let i = 0; i < name_list.length; i++) {
-      let name = name_list[i];
-      let v = obj[name];
-      let rule = rules[name];
-
-      if (!rule) {
-        rule = {};
-      }
-      if (!this.isSpecified(v)) {
-        if (rule.required) {
-          result = false;
-          this._error = {
-            code: 'MISSING_REQUIRED',
-            message: 'The `' + name + '` is required.'
-          };
-          break;
-        } else {
-          continue;
-        }
-      }
-
-      if (rule.type === 'float') {
-        result = this.isFloat(v, rule, name);
-      } else if (rule.type === 'integer') {
-        result = this.isInteger(v, rule, name);
-      } else if (rule.type === 'boolean') {
-        result = this.isBoolean(v, rule, name);
-      } else if (rule.type === 'array') {
-        result = this.isArray(v, rule, name);
-      } else if (rule.type === 'object') {
-        result = this.isObject(v, rule, name);
-      } else if (rule.type === 'string') {
-        result = this.isString(v, rule, name);
-      } else {
-        result = false;
-        this._error = {
-          code: 'TYPE_UNKNOWN',
-          message: 'The rule specified for the `' + name + '` includes an unknown type: ' + rule.type,
-        };
-      }
-
-      if (result === false) {
-        this._error.name = name;
-        break;
-      }
-    }
-
-    return result;
-  }
-
-  /* ------------------------------------------------------------------
+	check(obj, rules, required = false) {
+		this._error = null;
+		if (required) {
+			if (!this.isSpecified(obj)) {
+				this._error = {
+					code: "MISSING_REQUIRED",
+					message: "The first argument is missing."
+				};
+				return false;
+			}
+		} else {
+			if (!obj) {
+				return true;
+			}
+		}
+
+		if (!this.isObject(obj)) {
+			this._error = {
+				code: "MISSING_REQUIRED",
+				message: "The first argument is missing."
+			};
+			return false;
+		}
+
+		let result = true;
+		let name_list = Object.keys(rules);
+
+		for (let i = 0; i < name_list.length; i++) {
+			let name = name_list[i];
+			let v = obj[name];
+			let rule = rules[name];
+
+			if (!rule) {
+				rule = {};
+			}
+			if (!this.isSpecified(v)) {
+				if (rule.required) {
+					result = false;
+					this._error = {
+						code: "MISSING_REQUIRED",
+						message: "The `" + name + "` is required."
+					};
+					break;
+				} else {
+					continue;
+				}
+			}
+
+			if (rule.type === "float") {
+				result = this.isFloat(v, rule, name);
+			} else if (rule.type === "integer") {
+				result = this.isInteger(v, rule, name);
+			} else if (rule.type === "boolean") {
+				result = this.isBoolean(v, rule, name);
+			} else if (rule.type === "array") {
+				result = this.isArray(v, rule, name);
+			} else if (rule.type === "object") {
+				result = this.isObject(v, rule, name);
+			} else if (rule.type === "string") {
+				result = this.isString(v, rule, name);
+			} else {
+				result = false;
+				this._error = {
+					code: "TYPE_UNKNOWN",
+					message: "The rule specified for the `" + name + "` includes an unknown type: " + rule.type,
+				};
+			}
+
+			if (result === false) {
+				this._error.name = name;
+				break;
+			}
+		}
+
+		return result;
+	}
+
+	/* ------------------------------------------------------------------
   * isFloat(value, rule, name)
   * - Check if the value is a float
   *
@@ -152,53 +150,53 @@ class ParameterChecker {
   * - If the value is invalid, this method will return `false` and
   *   an `Error` object will be set to `this._error`.
   * ---------------------------------------------------------------- */
-  isFloat(value, rule = {}, name = 'value') {
-    this._error = null;
-
-    if (!rule.required && !this.isSpecified(value)) {
-      return true;
-    }
-
-    if (typeof (value) !== 'number') {
-      this._error = {
-        code: 'TYPE_INVALID',
-        message: 'The `' + name + '` must be a number (integer or float).'
-      };
-      return false;
-    }
-
-    if (typeof (rule.min) === 'number') {
-      if (value < rule.min) {
-        this._error = {
-          code: 'VALUE_UNDERFLOW',
-          message: 'The `' + name + '` must be grater than or equal to ' + rule.min + '.'
-        };
-        return false;
-      }
-    }
-    if (typeof (rule.max) === 'number') {
-      if (value > rule.max) {
-        this._error = {
-          code: 'VALUE_OVERFLOW',
-          message: 'The `' + name + '` must be less than or equal to ' + rule.max + '.'
-        };
-        return false;
-      }
-    }
-    if (Array.isArray(rule.enum) && rule.enum.length > 0) {
-      if (rule.enum.indexOf(value) === -1) {
-        this._error = {
-          code: 'ENUM_UNMATCH',
-          message: 'The `' + name + '` must be any one of ' + JSON.stringify(rule.enum) + '.'
-        };
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /* ------------------------------------------------------------------
+	isFloat(value, rule = {}, name = "value") {
+		this._error = null;
+
+		if (!rule.required && !this.isSpecified(value)) {
+			return true;
+		}
+
+		if (typeof (value) !== "number") {
+			this._error = {
+				code: "TYPE_INVALID",
+				message: "The `" + name + "` must be a number (integer or float)."
+			};
+			return false;
+		}
+
+		if (typeof (rule.min) === "number") {
+			if (value < rule.min) {
+				this._error = {
+					code: "VALUE_UNDERFLOW",
+					message: "The `" + name + "` must be grater than or equal to " + rule.min + "."
+				};
+				return false;
+			}
+		}
+		if (typeof (rule.max) === "number") {
+			if (value > rule.max) {
+				this._error = {
+					code: "VALUE_OVERFLOW",
+					message: "The `" + name + "` must be less than or equal to " + rule.max + "."
+				};
+				return false;
+			}
+		}
+		if (Array.isArray(rule.enum) && rule.enum.length > 0) {
+			if (rule.enum.indexOf(value) === -1) {
+				this._error = {
+					code: "ENUM_UNMATCH",
+					message: "The `" + name + "` must be any one of " + JSON.stringify(rule.enum) + "."
+				};
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/* ------------------------------------------------------------------
   * isInteger(value, rule)
   * - Check if the value is an integer
   *
@@ -219,29 +217,29 @@ class ParameterChecker {
   * - If the value is invalid, this method will return `false` and
   *   an `Error` object will be set to `this._error`.
   * ---------------------------------------------------------------- */
-  isInteger(value, rule = {}, name = 'value') {
-    this._error = null;
-
-    if (!rule.required && !this.isSpecified(value)) {
-      return true;
-    }
-
-    if (this.isFloat(value, rule)) {
-      if (value % 1 === 0) {
-        return true;
-      } else {
-        this._error = {
-          code: 'TYPE_INVALID',
-          message: 'The `' + name + '` must be an integer.'
-        };
-        return false;
-      }
-    } else {
-      return false;
-    }
-  }
-
-  /* ------------------------------------------------------------------
+	isInteger(value, rule = {}, name = "value") {
+		this._error = null;
+
+		if (!rule.required && !this.isSpecified(value)) {
+			return true;
+		}
+
+		if (this.isFloat(value, rule)) {
+			if (value % 1 === 0) {
+				return true;
+			} else {
+				this._error = {
+					code: "TYPE_INVALID",
+					message: "The `" + name + "` must be an integer."
+				};
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+
+	/* ------------------------------------------------------------------
   * isBoolean(value, rule, name)
   * - Check if the value is a boolean.
   *
@@ -256,24 +254,24 @@ class ParameterChecker {
   * - If the value is invalid, this method will return `false` and
   *   an `Error` object will be set to `this._error`.
   * ---------------------------------------------------------------- */
-  isBoolean(value, rule = {}, name = 'value') {
-    this._error = null;
-
-    if (!rule.required && !this.isSpecified(value)) {
-      return true;
-    }
-
-    if (typeof (value) !== 'boolean') {
-      this._error = {
-        code: 'TYPE_INVALID',
-        message: 'The `' + name + '` must be boolean.'
-      };
-      return false;
-    }
-    return true;
-  }
-
-  /* ------------------------------------------------------------------
+	isBoolean(value, rule = {}, name = "value") {
+		this._error = null;
+
+		if (!rule.required && !this.isSpecified(value)) {
+			return true;
+		}
+
+		if (typeof (value) !== "boolean") {
+			this._error = {
+				code: "TYPE_INVALID",
+				message: "The `" + name + "` must be boolean."
+			};
+			return false;
+		}
+		return true;
+	}
+
+	/* ------------------------------------------------------------------
   * isObject(value)
   * - Check if the value is an object
   *
@@ -288,23 +286,23 @@ class ParameterChecker {
   * - If the value is invalid, this method will return `false` and
   *   an `Error` object will be set to `this._error`.
   * ---------------------------------------------------------------- */
-  isObject(value, rule = {}, name = 'value') {
-    this._error = null;
-    if (!rule.required && !this.isSpecified(value)) {
-      return true;
-    }
-
-    if (typeof (value) !== 'object' || value === null || Array.isArray(value)) {
-      this._error = {
-        code: 'TYPE_INVALID',
-        message: 'The `' + name + '` must be an object.'
-      };
-      return false;
-    }
-    return true;
-  }
-
-  /* ------------------------------------------------------------------
+	isObject(value, rule = {}, name = "value") {
+		this._error = null;
+		if (!rule.required && !this.isSpecified(value)) {
+			return true;
+		}
+
+		if (typeof (value) !== "object" || value === null || Array.isArray(value)) {
+			this._error = {
+				code: "TYPE_INVALID",
+				message: "The `" + name + "` must be an object."
+			};
+			return false;
+		}
+		return true;
+	}
+
+	/* ------------------------------------------------------------------
   * isArray(value, rule, name)
   * - Check if the value is an `Array` object
   *
@@ -324,44 +322,44 @@ class ParameterChecker {
   * - If the value is invalid, this method will return `false` and
   *   an `Error` object will be set to `this._error`.
   * ---------------------------------------------------------------- */
-  isArray(value, rule = {}, name = 'value') {
-    this._error = null;
-
-    if (!rule.required && !this.isSpecified(value)) {
-      return true;
-    }
-
-    if (!Array.isArray(value)) {
-      this._error = {
-        code: 'TYPE_INVALID',
-        message: 'The value must be an array.'
-      };
-      return false;
-    }
-
-    if (typeof (rule.min) === 'number') {
-      if (value.length < rule.min) {
-        this._error = {
-          code: 'LENGTH_UNDERFLOW',
-          message: 'The number of characters in the `' + name + '` must be grater than or equal to ' + rule.min + '.'
-        };
-        return false;
-      }
-    }
-    if (typeof (rule.max) === 'number') {
-      if (value.length > rule.max) {
-        this._error = {
-          code: 'LENGTH_OVERFLOW',
-          message: 'The number of characters in the `' + name + '` must be less than or equal to ' + rule.max + '.'
-        };
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /* ------------------------------------------------------------------
+	isArray(value, rule = {}, name = "value") {
+		this._error = null;
+
+		if (!rule.required && !this.isSpecified(value)) {
+			return true;
+		}
+
+		if (!Array.isArray(value)) {
+			this._error = {
+				code: "TYPE_INVALID",
+				message: "The value must be an array."
+			};
+			return false;
+		}
+
+		if (typeof (rule.min) === "number") {
+			if (value.length < rule.min) {
+				this._error = {
+					code: "LENGTH_UNDERFLOW",
+					message: "The number of characters in the `" + name + "` must be grater than or equal to " + rule.min + "."
+				};
+				return false;
+			}
+		}
+		if (typeof (rule.max) === "number") {
+			if (value.length > rule.max) {
+				this._error = {
+					code: "LENGTH_OVERFLOW",
+					message: "The number of characters in the `" + name + "` must be less than or equal to " + rule.max + "."
+				};
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/* ------------------------------------------------------------------
   * isString(value, rule, name)
   * - Check if the value is an `Array` object
   *
@@ -385,80 +383,80 @@ class ParameterChecker {
   * - If the value is invalid, this method will return `false` and
   *   an `Error` object will be set to `this._error`.
   * ---------------------------------------------------------------- */
-  isString(value, rule = {}, name = 'value') {
-    this._error = null;
-
-    if (!rule.required && !this.isSpecified(value)) {
-      return true;
-    }
-
-    if (typeof (value) !== 'string') {
-      this._error = {
-        code: 'TYPE_INVALID',
-        message: 'The value must be a string.'
-      };
-      return false;
-    }
-
-    if (typeof (rule.min) === 'number') {
-      if (value.length < rule.min) {
-        this._error = {
-          code: 'LENGTH_UNDERFLOW',
-          message: 'The number of characters in the `' + name + '` must be grater than or equal to ' + rule.min + '.'
-        };
-        return false;
-      }
-    }
-    if (typeof (rule.max) === 'number') {
-      if (value.length > rule.max) {
-        this._error = {
-          code: 'LENGTH_OVERFLOW',
-          message: 'The number of characters in the `' + name + '` must be less than or equal to ' + rule.max + '.'
-        };
-        return false;
-      }
-    }
-    if (typeof (rule.minBytes) === 'number') {
-      let blen = Buffer.from(value, 'utf8').length;
-      if (blen < rule.minBytes) {
-        this._error = {
-          code: 'LENGTH_UNDERFLOW',
-          message: 'The byte length of the `' + name + '` (' + blen + ' bytes) must be grater than or equal to ' + rule.minBytes + ' bytes.'
-        };
-        return false;
-      }
-    }
-    if (typeof (rule.maxBytes) === 'number') {
-      let blen = Buffer.from(value, 'utf8').length;
-      if (blen > rule.maxBytes) {
-        this._error = {
-          code: 'LENGTH_OVERFLOW',
-          message: 'The byte length of the `' + name + '` (' + blen + ' bytes) must be less than or equal to ' + rule.maxBytes + ' bytes.'
-        };
-        return false;
-      }
-    }
-    if (rule.pattern instanceof RegExp) {
-      if (!rule.pattern.test(v)) {
-        this._error = {
-          code: 'PATTERN_UNMATCH',
-          message: 'The `' + name + '` does not conform with the pattern.'
-        };
-        return false;
-      }
-    }
-    if (Array.isArray(rule.enum) && rule.enum.length > 0) {
-      if (rule.enum.indexOf(value) === -1) {
-        this._error = {
-          code: 'ENUM_UNMATCH',
-          message: 'The `' + name + '` must be any one of ' + JSON.stringify(rule.enum) + '.'
-        };
-        return false;
-      }
-    }
-
-    return true;
-  }
+	isString(value, rule = {}, name = "value") {
+		this._error = null;
+
+		if (!rule.required && !this.isSpecified(value)) {
+			return true;
+		}
+
+		if (typeof (value) !== "string") {
+			this._error = {
+				code: "TYPE_INVALID",
+				message: "The value must be a string."
+			};
+			return false;
+		}
+
+		if (typeof (rule.min) === "number") {
+			if (value.length < rule.min) {
+				this._error = {
+					code: "LENGTH_UNDERFLOW",
+					message: "The number of characters in the `" + name + "` must be grater than or equal to " + rule.min + "."
+				};
+				return false;
+			}
+		}
+		if (typeof (rule.max) === "number") {
+			if (value.length > rule.max) {
+				this._error = {
+					code: "LENGTH_OVERFLOW",
+					message: "The number of characters in the `" + name + "` must be less than or equal to " + rule.max + "."
+				};
+				return false;
+			}
+		}
+		if (typeof (rule.minBytes) === "number") {
+			let blen = Buffer.from(value, "utf8").length;
+			if (blen < rule.minBytes) {
+				this._error = {
+					code: "LENGTH_UNDERFLOW",
+					message: "The byte length of the `" + name + "` (" + blen + " bytes) must be grater than or equal to " + rule.minBytes + " bytes."
+				};
+				return false;
+			}
+		}
+		if (typeof (rule.maxBytes) === "number") {
+			let blen = Buffer.from(value, "utf8").length;
+			if (blen > rule.maxBytes) {
+				this._error = {
+					code: "LENGTH_OVERFLOW",
+					message: "The byte length of the `" + name + "` (" + blen + " bytes) must be less than or equal to " + rule.maxBytes + " bytes."
+				};
+				return false;
+			}
+		}
+		if (rule.pattern instanceof RegExp) {
+			if (!rule.pattern.test(v)) {
+				this._error = {
+					code: "PATTERN_UNMATCH",
+					message: "The `" + name + "` does not conform with the pattern."
+				};
+				return false;
+			}
+		}
+		if (Array.isArray(rule.enum) && rule.enum.length > 0) {
+			if (rule.enum.indexOf(value) === -1) {
+				this._error = {
+					code: "ENUM_UNMATCH",
+					message: "The `" + name + "` must be any one of " + JSON.stringify(rule.enum) + "."
+				};
+				return false;
+			}
+		}
+
+		return true;
+	}
 }
 
-module.exports = new ParameterChecker();
+export default new ParameterChecker();