countingup 0.2.4 → 0.3.0

package/README.md

@@ -1,62 +1,62 @@
-# Countingup
-Countingup is a library that provides a Counter class to count up and down with customizations.
-## Installation
-Using npm:
-```
-$ npm install countingup
-```
-
-In Node.js
-```javascript
-const countingup = require('countingup')
-```
-
-# Counter class
-The ``Counter`` class provides a tool to count numbers.
-
-Initializing
-```javascript
-const Counter = countingup.Counter
-const myCounter = new Counter()
-```
-
-Counting
-```javascript
-myCounter.count()
-console.log(myCounter.getCurrentNumber()) // 1
-```
-
-Resetting
-```javascript
-myCounter.reset()
-console.log(myCounter.getCurrentNumber()) // 0
-```
-
-# Bonus Features
-Customizing the Increment
-```javascript
-myCounter.count()
-console.log(myCounter.getCurrentNumber()) // 1
-myCounter.count(3)
-console.log(myCounter.getCurrentNumber()) // 4
-```
-
-Customizing the Direction
-
-This allows you to change the direction so it counts down and subtracts
-```javascript
-myCounter.reset()
-myCounter.count(5)
-console.log(myCounter.getCurrentNumber()) // 5
-myCounter.count(5, countingup.DIRECTION.REVERSE) // 0
-```
-By default it will be forwards (countingup.DIRECTION.FORWARDS)
-
-Customizing the Starting Number
-
-```javascript
-const myCounter2 = new Counter(4)
-console.log(myCounter2.getCurrentNumber()) // 4
-myCounter2.reset(3)
-console.log(myCounter2.getCurrentNumber()) // 3
-```
+# Countingup
+Countingup is a library that provides a Counter class to count up and down with customizations.
+## Installation
+Using npm:
+```
+$ npm install countingup
+```
+
+In Node.js
+```javascript
+const countingup = require('countingup')
+```
+
+# Counter class
+The ``Counter`` class provides a tool to count numbers.
+
+Initializing
+```javascript
+const Counter = countingup.Counter
+const myCounter = new Counter()
+```
+
+Counting
+```javascript
+myCounter.count()
+console.log(myCounter.getCurrentNumber()) // 1
+```
+
+Resetting
+```javascript
+myCounter.reset()
+console.log(myCounter.getCurrentNumber()) // 0
+```
+
+# Bonus Features
+Customizing the Increment
+```javascript
+myCounter.count()
+console.log(myCounter.getCurrentNumber()) // 1
+myCounter.count(3)
+console.log(myCounter.getCurrentNumber()) // 4
+```
+
+Customizing the Direction
+
+This allows you to change the direction so it counts down and subtracts
+```javascript
+myCounter.reset()
+myCounter.count(5)
+console.log(myCounter.getCurrentNumber()) // 5
+myCounter.count(5, countingup.Counter.DIRECTION.REVERSE) // 0
+```
+By default it will be forwards (countingup.Counter.DIRECTION.FORWARDS)
+
+Customizing the Starting Number
+
+```javascript
+const myCounter2 = new Counter(4)
+console.log(myCounter2.getCurrentNumber()) // 4
+myCounter2.reset(3)
+console.log(myCounter2.getCurrentNumber()) // 3
+```

package/index.js

@@ -1 +1 @@
-module.exports = require('countingup/lib')
+module.exports = require('./lib/index')

package/index.test.js

@@ -0,0 +1,81 @@
+const { expect } = require("chai")
+const { Counter } = require("./index")
+
+describe("Counter Library", () => {
+  let counter
+
+  beforeEach(() => {
+    counter = new Counter(10)
+  })
+
+  describe("Initialization", () => {
+    it("should initialize with a base value", () => {
+      expect(counter.getCurrentNumber()).to.equal(10)
+    })
+
+    it("should default to 0 if no base is provided or is invalid", () => {
+      const defaultCounter = new Counter()
+      const invalidCounter = new Counter("invalid")
+      expect(defaultCounter.getCurrentNumber()).to.equal(0)
+      expect(invalidCounter.getCurrentNumber()).to.equal(0)
+    })
+  })
+
+  describe("Counting Logic", () => {
+    it("should increment by 1 when count is called with no arguments", () => {
+      counter.count()
+      expect(counter.getCurrentNumber()).to.equal(11)
+    })
+
+    it("should increment by a specific amount in FORWARDS direction", () => {
+      counter.count(5, Counter.DIRECTION.FORWARDS)
+      expect(counter.getCurrentNumber()).to.equal(15)
+    })
+
+    it("should decrement by a specific amount in REVERSE direction", () => {
+      counter.count(5, Counter.DIRECTION.REVERSE)
+      expect(counter.getCurrentNumber()).to.equal(5)
+    })
+  })
+
+  describe("Reset Functionality", () => {
+    it("should reset the counter to a new base value", () => {
+      counter.reset(50)
+      expect(counter.getCurrentNumber()).to.equal(50)
+    })
+
+    it('should return "this" to allow chaining', () => {
+      const result = counter.reset(5)
+      expect(result).to.equal(counter)
+    })
+  })
+
+  describe("Error Handling (Throws)", () => {
+    it("should throw an error for non-integer increments", () => {
+      expect(() => {
+        counter.count(1.5)
+      }).to.throw("Invalid increment")
+    })
+
+    it("should throw an error for non-finite increments", () => {
+      expect(() => {
+        counter.count(Infinity)
+      }).to.throw("Invalid increment")
+    })
+
+    it("should throw an error for invalid directions", () => {
+      expect(() => {
+        counter.count(1, "INVALID_DIR")
+      }).to.throw("Invalid direction")
+    })
+
+    it("should not change the counter value if an error is thrown", () => {
+      try {
+        counter.count(1.5)
+      } catch (e) {
+        // Error expected
+      }
+      expect(counter.getCurrentNumber()).to.equal(10)
+    })
+  })
+})

package/lib/index.js

@@ -1,40 +1,46 @@
-module.exports = countingup = {
-  DIRECTION: {
-    FORWARDS: 'forwards',
-    REVERSE: 'reverse'
-  },
-  Counter: function Counter(base) {
-    if (base == null || !Number.isFinite(base)) base = 0
-    var counter = base
-    this.reset = function(base) {
-      if (base == null || !Number.isFinite(base)) base = 0
-      counter = base
-      return this
-    }
-    this.getCurrentNumber = function() {
-      return counter
-    }
-    this.count = function(increment, direction) {
-      if (increment == null) increment = 1
-      if (direction == null) direction = countingup.DIRECTION.FORWARDS
-      if (!Number.isFinite(increment) || !Number.isInteger(increment)) {
-        return console.error('Invalid increment')
-      }
-      switch (direction) {
-        case countingup.DIRECTION.FORWARDS: {
-          counter += increment
-          return
-        }
-
-        case countingup.DIRECTION.REVERSE: {
-          counter -= increment
-          return
-        }
-
-        default: {
-          return console.error('Invalid direction')
-        }
-      }
-    }
-  }
-}
+const DIRECTION = {
+  FORWARDS: 'forwards',
+  REVERSE: 'reverse'
+}
+
+const zero = require("@positive-numbers/zero")
+const one = require("@positive-numbers/one")
+const isNil = require("@is-(unknown)/is-nil")
+const isFinite = require("@is-(unknown)/is-finite")
+const isInteger = require("is-integer")
+const not = require("es-logical-not-operator")
+const or = require("es-logical-or-operator")
+const { immediateError, ErrorType } = require("immediate-error")
+const { Switch } = require("switch-in-fp")
+
+function Counter(base) {
+  if (or(isNil(base), not(isFinite(base)))) base = zero
+  var counter = base
+  this.reset = function(base) {
+    if (or(isNil(base), not(isFinite(base)))) base = zero
+    counter = base
+    return this
+  }
+  this.getCurrentNumber = function() {
+    return counter
+  }
+  this.count = function(increment, direction) {
+    if (isNil(increment)) increment = one
+    if (isNil(direction)) direction = DIRECTION.FORWARDS
+    if (or(not(isFinite(increment)), not(isInteger(increment)))) {
+      immediateError("Invalid increment (increment was not a finite integer)", ErrorType.RangeError)
+    }
+    Switch(direction).case(DIRECTION.FORWARDS, function() {
+      counter += increment
+    }).case(DIRECTION.REVERSE, function() {
+      counter -= increment
+    }).else(function() {
+      immediateError("Invalid direction (direction was expected to be \"forwards\" or \"reverse\"")
+    }).execute()
+  }
+}
+
+Counter.DIRECTION = DIRECTION
+module.exports = countingup = {
+  Counter
+}

package/package.json

@@ -1,27 +1,45 @@
-{
-  "name": "countingup",
-  "version": "0.2.4",
-  "description": "Counter Class for JavaScrippt",
-  "main": "index.js",
-  "directories": {
-    "lib": "lib"
-  },
-  "scripts": {},
-  "author": "Samuel Fox J.",
-  "license": "UNLICENSED",
-  "keywords": [
-    "math",
-    "js",
-    "utils",
-    "problems",
-    "calculations"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/tj-commits/countingup.git"
-  },
-  "bugs": {
-    "url": "https://github.com/tj-commits/countingup/issues"
-  },
-  "homepage": "https://github.com/tj-commits/countingup#readme"
-}
+{
+  "name": "countingup",
+  "version": "0.3.0",
+  "description": "Counter Class for JavaScript",
+  "main": "index.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "test": "mocha index.test.js"
+  },
+  "author": "Samuel Fox J.",
+  "license": "UNLICENSED",
+  "keywords": [
+    "math",
+    "js",
+    "utils",
+    "problems",
+    "calculations"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tj-commits/countingup.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tj-commits/countingup/issues"
+  },
+  "homepage": "https://github.com/tj-commits/countingup#readme",
+  "dependencies": {
+    "@is-(unknown)/is-finite": "^1.0.0",
+    "@is-(unknown)/is-nil": "^1.2.0",
+    "@positive-numbers/one": "^3.0.0",
+    "@positive-numbers/zero": "^3.0.0",
+    "es-logical-not-operator": "^1.0.0",
+    "es-logical-or-operator": "^1.0.0",
+    "immediate-error": "^7.1.0",
+    "is-integer": "^1.0.7",
+    "is-null": "^1.0.1",
+    "switch-in-fp": "^3.0.0"
+  },
+  "devDependencies": {
+    "chai": "^6.2.2",
+    "mocha": "^11.7.5"
+  }
+}