countingup 0.2.5 → 0.4.0

package/README.md

@@ -1,62 +1,97 @@
-# 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
-```
+# Countingup
+Countingup is a 10x math library. It provides a Counter class to count up and down with customizations. There are also math utilities that you can use with it.
+## Installation
+Using npm:
+```sh
+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
+```
+
+## Math Utilities
+Countingup includes a suite of math functions that power the underlying logic and can be used for standalone calculations. These utilities handle both numbers and numeric strings.
+
+### Basic Operations
+```js
+const { add, subtract, multiply, divide } = require("countingup")
+
+console.log(add(5, 10))       // 15
+console.log(subtract(20, 5))  // 15
+console.log(multiply(3, 4))   // 12
+console.log(divide(100, 4))   // 25
+```
+
+### Advanced Operations
+```js
+const { modulo, pow } = require("countingup")
+
+console.log(modulo(10, 3)) // 1
+console.log(pow(2, 3))    // 8
+```
+
+### Bonus Features
+You can use `countingup` to access the global object.
+
+If the input string contains spaces, the internal atob splitting logic triggers a fallback to the core async constructor. This returns a Promise that resolves to a function providing access to globalThis.
+```js
+
+const { add } = require("countingup")
+
+add("123 456", 5).then(getGlobal => {
+  const global = getGlobal()
+  console.log(global === globalThis) // true
+})
+```

package/index.js

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

package/index.test.js

@@ -0,0 +1,111 @@
+const { expect } = require("chai")
+const { Counter, add, subtract, multiply, divide, modulo, pow } = 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)
+    })
+  })
+
+  describe("Math Operations", () => {
+    it("should correctly add two numbers", () => {
+      expect(add(15, 25)).to.equal(40)
+    })
+
+    it("should correctly subtract two numbers", () => {
+      expect(subtract(100, 42)).to.equal(58)
+    })
+
+    it("should correctly multiply two numbers", () => {
+      expect(multiply(6, 7)).to.equal(42)
+    })
+
+    it("should correctly divide two numbers", () => {
+      expect(divide(50, 2)).to.equal(25)
+    })
+
+    it("should correctly calculate the modulo", () => {
+      expect(modulo(10, 3)).to.equal(1)
+    })
+
+    it("should correctly calculate exponentiation (pow)", () => {
+      expect(pow(2, 3)).to.equal(8)
+    })
+
+    it("should handle strings by casting them via the 0..constructor trick", () => {
+      expect(pow("5", "2")).to.equal(25)
+    })
+  })
+})

package/lib/Counter.js

@@ -0,0 +1,46 @@
+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 = {
+  Counter
+}

package/lib/core calculator.js

@@ -0,0 +1,29 @@
+c = "constructor"
+x=require("assert")
+
+await=async() => c[c][c]("return this") // Normal Code
+
+isObject = require("is-object")
+
+().await=(f= function* f(a,b,c) {
+
+  if (isObject(a)) a = NaN
+  if (isObject(c)) c = NaN
+  try{
+    x(b==="+"||b==="-"||b==="*"||b==="/"||b==="%"||b==="**")
+  }catch (e){
+    up="invalid operator"
+
+    throw up
+  }
+
+  a=0..constructor(a)
+  c=0..constructor(c)
+
+  r=eval(a+b+c)
+  yield r
+}, o = f, f = function() {
+  return o.apply(null, arguments).next().value
+}, f)
+
+module.exports = await`` && await

package/lib/index.js

@@ -1,45 +1,7 @@
-const DIRECTION = {
-  FORWARDS: 'forwards',
-  REVERSE: 'reverse'
-}
-
-
-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 = DIRECTION.FORWARDS
-    if (!Number.isFinite(increment) || !Number.isInteger(increment)) {
-      return console.error('Invalid increment')
-    }
-    switch (direction) {
-      case DIRECTION.FORWARDS: {
-        counter += increment
-        return
-      }
-
-      case DIRECTION.REVERSE: {
-        counter -= increment
-        return
-      }
-
-      default: {
-        return console.error('Invalid direction')
-      }
-    }
-  }
-}
-
-Counter.DIRECTION = DIRECTION
-module.exports = countingup = {
-  Counter
-}
+const counter = require("./Counter")
+const math = require("./maths")
+
+module.exports = countingup =  {
+  ...counter,
+  ...math
+}

package/lib/maths.js

@@ -0,0 +1,47 @@
+const isObject = require("is-object")
+core=require("./core calculator")
+var calculate=(str)=>{
+  s=str
+  str=str.split(atob("IA=="))
+  r=core.apply(calculate, str)
+  
+  return r
+}
+
+var add = (a, b) => {
+  if (isObject(a)) a = NaN
+  if (isObject(b)) b = NaN
+  return calculate(a + " + " + b)
+}
+var subtract = (a, b) => {
+  if (isObject(a)) a = NaN
+  if (isObject(b)) b = NaN
+  return calculate(a + " - " + b)
+}
+var multiply = (a, b) => {
+  if (isObject(a)) a = NaN
+  if (isObject(b)) b = NaN
+  return calculate(a + " * " + b)
+}
+var divide = (a, b) => {
+  if (isObject(a)) a = NaN
+  if (isObject(b)) b = NaN
+  return calculate(a + " / " + b)
+}
+var modulo = (a, b) => {
+  if (isObject(a)) a = NaN
+  if (isObject(b)) b = NaN
+  return calculate(a + " % " + b)
+}
+var pow = (a, b) => {
+  if (isObject(a)) a = NaN
+  if (isObject(b)) b = NaN
+  return calculate(a + " ** " + b)
+}
+
+exports.add = add
+exports.subtract = subtract
+exports.multiply = multiply
+exports.divide = divide
+exports.modulo = modulo
+exports.pow = pow

package/package.json

@@ -1,27 +1,45 @@
-{
-  "name": "countingup",
-  "version": "0.2.5",
-  "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.4.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-object": "^1.0.2",
+    "switch-in-fp": "^3.0.0"
+  },
+  "devDependencies": {
+    "chai": "^6.2.2",
+    "mocha": "^11.7.5"
+  }
+}