countingup 0.3.0 → 0.4.0

package/README.md

@@ -1,9 +1,9 @@
 # Countingup
-Countingup is a library that provides a Counter class to count up and down with customizations.
+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:
-```
-$ npm install countingup
+```sh
+npm install countingup
 ```
 
 In Node.js
@@ -11,7 +11,7 @@ In Node.js
 const countingup = require('countingup')
 ```
 
-# Counter class
+## Counter class
 The ``Counter`` class provides a tool to count numbers.
 
 Initializing
@@ -32,7 +32,7 @@ myCounter.reset()
 console.log(myCounter.getCurrentNumber()) // 0
 ```
 
-# Bonus Features
+### Bonus Features
 Customizing the Increment
 ```javascript
 myCounter.count()
@@ -60,3 +60,38 @@ 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.test.js

@@ -1,5 +1,5 @@
 const { expect } = require("chai")
-const { Counter } = require("./index")
+const { Counter, add, subtract, multiply, divide, modulo, pow } = require("./index")
 
 describe("Counter Library", () => {
   let counter
@@ -44,7 +44,7 @@ describe("Counter Library", () => {
       expect(counter.getCurrentNumber()).to.equal(50)
     })
 
-    it('should return "this" to allow chaining', () => {
+    it("should return \"this\" to allow chaining", () => {
       const result = counter.reset(5)
       expect(result).to.equal(counter)
     })
@@ -78,4 +78,34 @@ describe("Counter Library", () => {
       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,46 +1,7 @@
-const DIRECTION = {
-  FORWARDS: 'forwards',
-  REVERSE: 'reverse'
-}
+const counter = require("./Counter")
+const math = require("./maths")
 
-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
-}
+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,6 +1,6 @@
 {
   "name": "countingup",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Counter Class for JavaScript",
   "main": "index.js",
   "directories": {
@@ -35,7 +35,7 @@
     "es-logical-or-operator": "^1.0.0",
     "immediate-error": "^7.1.0",
     "is-integer": "^1.0.7",
-    "is-null": "^1.0.1",
+    "is-object": "^1.0.2",
     "switch-in-fp": "^3.0.0"
   },
   "devDependencies": {