@util.js/numbers 0.41.5 → 0.41.7

package/package.json

@@ -8,6 +8,10 @@
     "work in https://npm.runkit.com."
   ],
   "description": "JavaScript utility methods for numbers",
+  "files": [
+    "dist",
+    "index.js"
+  ],
   "keywords": [
     "int",
     "integer",
@@ -32,5 +36,5 @@
     "type": "git",
     "url": "https://github.com/creemama/utiljs/tree/master/packages/utiljs-numbers"
   },
-  "version": "0.41.5"
+  "version": "0.41.7"
 }

package/lib/Numbers.js

@@ -1,266 +0,0 @@
-"use strict";
-
-class Numbers {
-  abs() {
-    return Math.abs(...arguments);
-  }
-
-  acos() {
-    return Math.acos(...arguments);
-  }
-
-  acosh() {
-    return Math.acosh(...arguments);
-  }
-
-  ascendingComparator() {
-    const thiz = this;
-    return (a, b) => {
-      if (thiz.isNaN(a)) {
-        if (thiz.isNaN(b)) return 0;
-        else return 1;
-      } else if (thiz.isNaN(b)) {
-        return -1;
-      }
-      return a - b;
-    };
-  }
-
-  asin() {
-    return Math.asin(...arguments);
-  }
-
-  asinh() {
-    return Math.asinh(...arguments);
-  }
-
-  atan() {
-    return Math.atan(...arguments);
-  }
-
-  atan2() {
-    return Math.atan2(...arguments);
-  }
-
-  atanh() {
-    return Math.atanh(...arguments);
-  }
-
-  cbrt() {
-    return Math.cbrt(...arguments);
-  }
-
-  ceil() {
-    return Math.ceil(...arguments);
-  }
-
-  clz32() {
-    return Math.clz32(...arguments);
-  }
-
-  cos() {
-    return Math.cos(...arguments);
-  }
-
-  cosh() {
-    return Math.cosh(...arguments);
-  }
-
-  descendingComparator() {
-    const thiz = this;
-    return (a, b) => {
-      if (thiz.isNaN(a)) {
-        if (thiz.isNaN(b)) return 0;
-        else return -1;
-      } else if (thiz.isNaN(b)) {
-        return 1;
-      }
-      return b - a;
-    };
-  }
-
-  exp() {
-    return Math.exp(...arguments);
-  }
-
-  expm1() {
-    return Math.expm1(...arguments);
-  }
-
-  floor() {
-    return Math.floor(...arguments);
-  }
-
-  fround() {
-    return Math.fround(...arguments);
-  }
-
-  hypot() {
-    return Math.hypot(...arguments);
-  }
-
-  imul() {
-    return Math.imul(...arguments);
-  }
-
-  isFinite() {
-    return Number.isFinite(...arguments);
-  }
-
-  // http://stackoverflow.com/questions/14636536/how-to-check-if-a-variable-is-an-integer-in-javascript
-  isInt(value) {
-    if (this.isNaN(value)) return false;
-    const x = this.parseFloat(value);
-    return (x | 0) === x;
-  }
-
-  isInteger() {
-    return Number.isInteger(...arguments);
-  }
-
-  isNaN() {
-    return Number.isNaN(...arguments);
-  }
-
-  isSafeInteger() {
-    return Number.isSafeInteger(...arguments);
-  }
-
-  log() {
-    return Math.log(...arguments);
-  }
-
-  log10() {
-    return Math.log10(...arguments);
-  }
-
-  log1p() {
-    return Math.log1p(...arguments);
-  }
-
-  log2() {
-    return Math.log2(...arguments);
-  }
-
-  max() {
-    return Math.max(...arguments);
-  }
-
-  min() {
-    return Math.min(...arguments);
-  }
-
-  parseFloat() {
-    return Number.parseFloat(...arguments);
-  }
-
-  parseInt() {
-    return Number.parseInt(...arguments);
-  }
-
-  pow() {
-    return Math.pow(...arguments);
-  }
-
-  random() {
-    return Math.random(...arguments);
-  }
-
-  round() {
-    return Math.round(...arguments);
-  }
-
-  sign() {
-    return Math.sign(...arguments);
-  }
-
-  sin() {
-    return Math.sin(...arguments);
-  }
-
-  sinh() {
-    return Math.sinh(...arguments);
-  }
-
-  sqrt() {
-    return Math.sqrt(...arguments);
-  }
-
-  tan() {
-    return Math.tan(...arguments);
-  }
-
-  tanh() {
-    return Math.tanh(...arguments);
-  }
-
-  trunc() {
-    return Math.trunc(...arguments);
-  }
-
-  get E() {
-    return Math.E;
-  }
-
-  get EPSILON() {
-    return Number.EPSILON;
-  }
-
-  get LN10() {
-    return Math.LN10;
-  }
-
-  get LN2() {
-    return Math.LN2;
-  }
-
-  get LOG10E() {
-    return Math.LOG10E;
-  }
-
-  get LOG2E() {
-    return Math.LOG2E;
-  }
-
-  get MAX_SAFE_INTEGER() {
-    return Number.MAX_SAFE_INTEGER;
-  }
-
-  get MAX_VALUE() {
-    return Number.MAX_VALUE;
-  }
-
-  get MIN_SAFE_INTEGER() {
-    return Number.MIN_SAFE_INTEGER;
-  }
-
-  get MIN_VALUE() {
-    return Number.MIN_VALUE;
-  }
-
-  get NEGATIVE_INFINITY() {
-    return Number.NEGATIVE_INFINITY;
-  }
-
-  get NaN() {
-    return Number.NaN;
-  }
-
-  get PI() {
-    return Math.PI;
-  }
-
-  get POSITIVE_INFINITY() {
-    return Number.POSITIVE_INFINITY;
-  }
-
-  get SQRT1_2() {
-    return Math.SQRT1_2;
-  }
-
-  get SQRT2() {
-    return Math.SQRT2;
-  }
-}
-
-module.exports = Numbers;

package/test/NumbersTest.js

@@ -1,112 +0,0 @@
-"use strict";
-
-const { expect } = require("chai");
-const numbers = require("..");
-
-describe("Numbers#abs(x)", () => {
-  it("should calculate correctly", () => {
-    expect(numbers.abs(numbers.NEGATIVE_INFINITY)).to.eql(
-      numbers.POSITIVE_INFINITY,
-    );
-  });
-});
-
-describe("Numbers#cos(x)", () => {
-  it("should calculate correctly", () => {
-    expect(numbers.cos(numbers.PI)).to.eql(-1);
-  });
-});
-
-describe("Numbers", () => {
-  describe("#ascendingComparator", () => {
-    it("should order arrays of numbers in ascending order", () => {
-      const expected = [
-        numbers.NEGATIVE_INFINITY,
-        -33,
-        0,
-        33.33,
-        numbers.POSITIVE_INFINITY,
-        numbers.NaN,
-        numbers.NaN,
-      ];
-      const actual = [
-        numbers.POSITIVE_INFINITY,
-        0,
-        numbers.NaN,
-        numbers.NEGATIVE_INFINITY,
-        -33,
-        numbers.NaN,
-        33.33,
-      ].sort(numbers.ascendingComparator());
-      expect(actual).to.deep.equal(expected);
-    });
-  });
-
-  describe("#descendingComparator", () => {
-    it("should order arrays of numbers in descending order", () => {
-      const expected = [
-        numbers.NaN,
-        numbers.NaN,
-        numbers.NaN,
-        numbers.POSITIVE_INFINITY,
-        33.33,
-        0,
-        -33,
-        numbers.NEGATIVE_INFINITY,
-      ];
-      const actual = [
-        numbers.NaN,
-        numbers.POSITIVE_INFINITY,
-        0,
-        numbers.NaN,
-        numbers.NEGATIVE_INFINITY,
-        -33,
-        numbers.NaN,
-        33.33,
-      ].sort(numbers.descendingComparator());
-      expect(actual).to.deep.equal(expected);
-    });
-  });
-
-  describe("#isInt(value)", () => {
-    it("should return true for integers", () => {
-      expect(numbers.isInt(-33)).to.be.true;
-      expect(numbers.isInt(0)).to.be.true;
-      expect(numbers.isInt(5)).to.be.true;
-    });
-    it("should return true for integers as strings", () => {
-      expect(numbers.isInt("-33")).to.be.true;
-      expect(numbers.isInt("0")).to.be.true;
-      expect(numbers.isInt("5")).to.be.true;
-    });
-    it("should return true for objects whose #toString evaluates to an integer", () => {
-      expect(numbers.isInt([5])).to.be.true;
-      expect(numbers.isInt([5, 6])).to.be.true;
-      expect(numbers.isInt({ toString: () => "5" })).to.be.true;
-    });
-    it("should return false for numbers with a nonzero fractional part", () => {
-      expect(numbers.isInt(-33.3)).to.be.false;
-      expect(numbers.isInt(0.1)).to.be.false;
-      expect(numbers.isInt(1e-5)).to.be.false;
-    });
-    it("should return false for numbers (as strings) with a nonzero fractional part", () => {
-      expect(numbers.isInt("")).to.be.false;
-      expect(numbers.isInt("-33.3")).to.be.false;
-      expect(numbers.isInt("0.1")).to.be.false;
-      expect(numbers.isInt("1e-5")).to.be.false;
-    });
-    it("should return false for objects whose #toString does not evaluate to an integer", () => {
-      expect(numbers.isInt([])).to.be.false;
-      expect(numbers.isInt({})).to.be.false;
-      expect(numbers.isInt([5.5, 5])).to.be.false;
-      expect(numbers.isInt({ toString: () => "5.5" })).to.be.false;
-    });
-    it("should return false for undefined, null, NaN, or infinite input", () => {
-      expect(numbers.isInt()).to.be.false;
-      expect(numbers.isInt(null)).to.be.false;
-      expect(numbers.isInt(NaN)).to.be.false;
-      expect(numbers.isInt(Infinity)).to.be.false;
-      expect(numbers.isInt(Number.NEGATIVE_INFINITY)).to.be.false;
-    });
-  });
-});