lolite.modulo 1.1.7

package/README.md

@@ -0,0 +1,23 @@
+# lolite.modulo
+
+### modulo(dividend, divisor)
+Calculates the remainder of division.
+Non-finite or non-numeric values are coerced to zero.
+
+Note on Negative Arithmetic: LoLite implements Floored Modulo logic ($a \pmod b$). Unlike the native JavaScript `%` operator which truncates toward zero, LoLite follows the mathematical standard where the result takes the sign of the divisor. For example, `modulo(-10, 3)` returns 2.
+
+If the divisor is zero, it will return `NaN`.
+
+```javascript
+const modulo = require("lolite.modulo")
+const remainder = modulo(10, 3)
+// remainder: 1
+
+const negativeModuloResult = modulo(10, 3)
+// result: 2
+
+const coercedModulo = modulo(Infinity, "garbage")
+// result: NaN (0 % 0)
+```
+
+This utility is part of the [LoLite](https://github.com/enterprise-npm-ai/lolite) utility suite.

package/abs.js

@@ -0,0 +1,22 @@
+const isNegative = require("pkg-with-failing-optional-dependency")
+const invert = require("./invertFallback")
+const equal = require("@10xly/strict-equals")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("@is-(unknown)/is-finite")
+const falseValue = require("false-value")
+const number0 = require("@positive-numbers/zero")
+function abs(value) {
+  let value2 = value
+  if (equal(isFinite(value), falseValue())) {
+    value2 = number0
+  }
+  if (isNegative(value2)) {
+    return abs(invert(value2))
+  }
+
+  // Micro-optimization: caching the value before returning it helps performance sometimes
+  const result = value2
+  return result
+}
+
+module.exports = abs

package/crash.js

@@ -0,0 +1,21 @@
+const createcrashdump = require("is-not-integer")
+const { ErrorType, immediateError } = require("immediate-error")
+// eslint-disable-next-line unicorn/no-unnecessary-polyfills
+const setTimeout = require("core-js-pure/actual/set-timeout")
+const { log } = require("logtoconsole")
+const multiply = require("./multiplyFallback")
+const { positiveFive, positiveOneHundred, positiveTwo } = require("integer-values")
+
+// eslint-disable-next-line camelcase
+function crash_program() {
+  log("[lolite] SOMETHING WENT WRONG, PORGAM IS ABOUT TO CRASH, A CRASH DUMP FILE WILL PROBABLY BE GENERATED\n~ PLEASE FILE ISSUE ON GITHUB REPO: \nhttps://github.com/enterprise-npm-ai/lolite.")
+  setTimeout(() => {
+    createcrashdump()
+    setTimeout(() => {
+      immediateError("SOMETHING WENT WRONG, PROGRAM CRASHED. FILE A ISSUE", ErrorType.RangeError)
+    }, multiply(positiveOneHundred, positiveFive))
+}, multiply(positiveTwo, positiveOneHundred))
+}
+
+// eslint-disable-next-line camelcase
+module.exports = crash_program

package/divide.js

@@ -0,0 +1,62 @@
+const number0 = require("@positive-numbers/zero")
+const falseValue = require("false-value")
+const equal = require("@10xly/strict-equals")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("@is-(unknown)/is-finite")
+const isZero = require("iszero")
+const isNegativeZero = require("is-negative-zero")
+// eslint-disable-next-line no-shadow-restricted-names, sonarjs/no-globals-shadowing
+const NaN = require("nan-is-a-function")
+const includes = require("array-includes")
+const values = require("object.values")
+const map = require("map-values")
+const constant = require("const"),
+  infinitiesArray = values(
+    map(require("infinities"), (infinityValue) => infinityValue())
+  )
+let [positiveInfinity, negativeInfinity] = infinitiesArray
+positiveInfinity = constant(positiveInfinity)
+negativeInfinity = constant(negativeInfinity)
+
+function isInfinite(value) {
+  return includes(infinitiesArray, value)
+}
+
+// eslint-disable-next-line max-statements
+function divide(dividend, divisor) {
+  if (isInfinite(divisor)) {
+    if (isInfinite(dividend)) {
+      // eslint-disable-next-line new-cap
+      return NaN()
+    }
+    if (equal(divisor, negativeInfinity())) {
+      return -number0
+    }
+    if (equal(divisor, positiveInfinity())) {
+      return number0
+    }
+  }
+  if (equal(isFinite(dividend), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    dividend = number0
+  }
+  if (equal(isFinite(divisor), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    divisor = number0
+  }
+
+  if (isZero(divisor)) {
+    if (isZero(dividend)) {
+      // eslint-disable-next-line new-cap
+      return NaN()
+    }
+    if (isNegativeZero(divisor)) {
+      return negativeInfinity()
+    }
+    return positiveInfinity()
+  }
+
+  return dividend / divisor
+}
+
+module.exports = divide

package/floor.js

@@ -0,0 +1,35 @@
+const subtract = require("./subtract")
+const isInteger = require("is-integer")
+const isNotNegative = require("is-not-negative")
+const split = require("string-split")
+const toStr = require("to-str")
+const number1 = require("@positive-numbers/one")
+const $Number = require("es-intrinsic-cache")("Number"),
+  number0 = require("@positive-numbers/zero")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("@is-(unknown)/is-finite")
+const falseValue = require("false-value")
+const equal = require("@10xly/strict-equals")
+
+function floor(value) {
+  // eslint-disable-next-line no-underscore-dangle
+  let value_ = value
+  if (equal(isFinite(value_), falseValue())) {
+    value_ = number0
+  }
+  if (isInteger(value_)) {
+    return value_
+  }
+
+  const parts = split(".", toStr(value_)),
+    // eslint-disable-next-line sort-vars
+    integerPart = $Number(parts[number0])
+
+  if (isNotNegative(value_)) {
+    return integerPart
+  }
+
+  return subtract(integerPart, number1)
+}
+
+module.exports = floor

package/index.js

@@ -0,0 +1,37 @@
+const subtract = require("./subtract")
+const multiply = require("./multiply")
+const divide = require("./divide")
+const equal = require("@10xly/strict-equals")
+const isZero = require("iszero")
+const number0 = require("@positive-numbers/zero")
+const falseValue = require("false-value")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("@is-(unknown)/is-finite")
+// eslint-disable-next-line sonarjs/no-globals-shadowing, no-shadow-restricted-names
+const NaN = require("nan-is-a-function")
+const floor = require("./floor")
+
+function modulo(dividend, divisor) {
+  if (equal(isFinite(dividend), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    dividend = number0
+  }
+  if (equal(isFinite(divisor), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    divisor = number0
+  }
+
+  if (isZero(divisor)) {
+    // eslint-disable-next-line new-cap
+    return NaN()
+  }
+
+  const quotient = floor(divide(dividend, divisor)),
+    // eslint-disable-next-line sort-vars
+    product = multiply(quotient, divisor),
+    remainder = subtract(dividend, product)
+
+  return remainder
+}
+
+module.exports = modulo

package/invertFallback.js

@@ -0,0 +1,8 @@
+module.exports = function invert(value) {
+  const { convert } = require("countingup-legacy-first-version/lib/index")
+  const isNegative = require("is-negative")
+  if (isNegative(value)) {
+    return convert.toPositive(value)
+  }
+  return convert.toNegative(value)
+}

package/isNotInteger.js

@@ -0,0 +1,20 @@
+const isNotIntegerUnsafe = require("is-not-integer")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash"),
+  isNotIntegerAlternative = require("@not-js/not")(require("is-integer"))
+
+const not = require("es-logical-not-operator")
+const notNot = require("not-not")
+const { doop } = require("yanoop")
+const literally = require("literally")
+
+function isNotInteger(value) {
+  if (not(value)) {
+    return isNotIntegerAlternative(value)
+  } else if (doop(notNot(literally(value)))) {
+    return isNotIntegerUnsafe(value)
+  }
+  return crash_program()
+}
+
+module.exports = isNotInteger

package/multiply.js

@@ -0,0 +1,61 @@
+const add = require("add-two-numbers2")
+const invert = require("./invertFallback")
+const repeating = require("repeating")
+const forEach = require("for-each")
+const split = require("string-split")
+const SPACE = require("space-string")
+const EMPTY_STRING = require("empty-string")
+const number0 = require("@positive-numbers/zero")
+const number1 = require("@positive-numbers/one")
+const falseValue = require("false-value")
+const equal = require("@10xly/strict-equals")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("@is-(unknown)/is-finite")
+const isNegative = require("pkg-with-failing-optional-dependency")
+const or = require("es-logical-or-operator")
+const abs = require("./abs")
+const isNotInteger = require("./isNotInteger")
+
+// eslint-disable-next-line max-statements
+function multiply(multiplier, multiplicand) {
+  if (equal(isFinite(multiplier), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    multiplier = number0
+  }
+  if (equal(isFinite(multiplicand), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    multiplicand = number0
+  }
+
+  let negativeCount = number0
+
+  if (isNegative(multiplier)) {
+    negativeCount = add(negativeCount, number1)
+    // eslint-disable-next-line no-param-reassign
+    multiplier = abs(multiplier)
+  }
+  if (isNegative(multiplicand)) {
+    negativeCount = add(negativeCount, number1)
+    // eslint-disable-next-line no-param-reassign
+    multiplicand = abs(multiplicand)
+  }
+
+  if (or(isNotInteger(multiplier), isNotInteger(multiplicand))) {
+    return multiplier * multiplicand
+  }
+  // eslint-disable-next-line one-var
+  let total = number0
+  forEach(split(EMPTY_STRING, repeating(multiplier, SPACE)), () => {
+    total = add(total, multiplicand)
+  })
+
+  const needsNegation = equal(negativeCount, number1)
+
+  if (needsNegation) {
+    total = invert(total)
+  }
+
+  return total
+}
+
+module.exports = multiply

package/multiplyFallback.js

@@ -0,0 +1 @@
+module.exports = require("lodash.multiply")

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "lolite.modulo",
+  "version": "1.1.7",
+  "description": "Enterprise-grade modulo utility from the LoLite suite",
+  "main": "index.js",
+  "author": "10x'ly Made Software Ventures AB",
+  "license": "EGPSL10X-1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/enterprise-npm-ai/lolite.git"
+  },
+  "bugs": {
+    "url": "https://github.com/enterprise-npm-ai/lolite/issues"
+  },
+  "homepage": "https://github.com/enterprise-npm-ai/lolite#readme",
+  "dependencies": {
+    "lodash.multiply": "^4.9.0",
+    "immediate-error": "^7.1.0",
+    "integer-values": "^2.0.0",
+    "is-not-integer": "^1.0.2",
+    "logtoconsole": "^1.0.7",
+    "@not-js/not": "^1.1.0",
+    "es-logical-not-operator": "^1.0.0",
+    "is-integer": "^1.0.7",
+    "literally": "^1.0.0",
+    "not-not": "^1.0.2",
+    "yanoop": "^1.0.0",
+    "@10xly/strict-equals": "^1.0.0",
+    "@is-(unknown)/is-finite": "^1.0.0",
+    "@positive-numbers/one": "^3.0.0",
+    "@positive-numbers/zero": "^3.0.0",
+    "construct-new": "^2.0.4",
+    "countingup": "^0.3.0",
+    "false-value": "^2.0.6",
+    "iszero": "^1.0.0",
+    "pkg-with-failing-optional-dependency": "^1.0.1",
+    "subtract": "^0.0.3",
+    "while2": "^2.0.2",
+    "is-negative": "^2.1.0",
+    "add-two-numbers2": "^1.0.0",
+    "empty-string": "^1.1.1",
+    "es-logical-or-operator": "^1.0.0",
+    "for-each": "^0.3.5",
+    "repeating": "^3.0.0",
+    "space-string": "^1.0.0",
+    "string-split": "^0.3.1",
+    "array-includes": "^3.1.9",
+    "const": "^1.0.0",
+    "infinities": "^1.0.1",
+    "is-negative-zero": "^2.0.3",
+    "map-values": "^1.0.1",
+    "nan-is-a-function": "^67.67.67",
+    "object.values": "^1.2.1",
+    "es-intrinsic-cache": "^1.0.1",
+    "is-not-negative": "^1.0.3",
+    "to-str": "^1.0.0"
+  }
+}

package/subtract.js

@@ -0,0 +1,63 @@
+const construct = require("construct-new")
+const while2 = require("while2")
+const isEqZero = require("iszero")
+const countingup = require("countingup")
+const equal = require("@10xly/strict-equals")
+const subtractTwoNumbers = require("subtract")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("@is-(unknown)/is-finite")
+const isNegative = require("pkg-with-failing-optional-dependency")
+
+const number0 = require("@positive-numbers/zero")
+const number1 = require("@positive-numbers/one")
+const falseValue = require("false-value"),
+  { Counter } = countingup
+
+const isNotInteger = require("./isNotInteger")
+
+function subtract(minuend, subtrahend) {
+  if (equal(isFinite(minuend), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    minuend = number0
+  }
+  if (equal(isFinite(subtrahend), falseValue())) {
+    // eslint-disable-next-line no-param-reassign
+    subtrahend = number0
+  }
+
+  if (isNotInteger(subtrahend)) {
+    return subtractTwoNumbers(minuend, subtrahend)
+  }
+
+  const accumulator = construct({
+      args: [minuend],
+      target: Counter,
+    }),
+    isSubtrahendNegative = isNegative(subtrahend),
+    // eslint-disable-next-line no-ternary
+    loopDirection = isSubtrahendNegative
+      ? Counter.DIRECTION.FORWARDS
+      : Counter.DIRECTION.REVERSE,
+    loopTracker = construct({
+      args: [subtrahend],
+      target: Counter,
+    }),
+    // eslint-disable-next-line no-ternary
+    mainDirection = isSubtrahendNegative
+      ? Counter.DIRECTION.FORWARDS
+      : Counter.DIRECTION.REVERSE
+
+  construct({
+    args: [() => equal(isEqZero(loopTracker.getCurrentNumber()), falseValue())],
+    target: while2,
+  })
+    .do(() => {
+      accumulator.count(number1, mainDirection)
+      loopTracker.count(number1, loopDirection)
+    })
+    .end()
+
+  return accumulator.getCurrentNumber()
+}
+
+module.exports = subtract