lolite.clamp 1.1.6

package/README.md

@@ -0,0 +1,21 @@
+# lolite.clamp
+
+### clamp(value, lower, upper)
+Restricts a value to be within the specified bounds.
+Non-finite or non-numeric values are coerced to zero.
+
+Note: If lower bound exceeds upper bound after coercion, the function prioritizes the lower bound.
+```javascript
+const lolite = require("lolite")
+const result = clamp(5, 1, 10)
+// result: 5
+
+const capped = clamp(15, 1, 10)
+// result: 10
+
+const raised = clamp(-5, 1, 10)
+// result: 1
+
+const coercedClamp = clamp(Infinity, "garbage", NaN)
+// result: 0 (0 clamped between 0 and 0)
+```

package/and.js

@@ -0,0 +1,15 @@
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+const not = require("./not")
+
+function and(firstCondition, secondCondition) {
+  if (firstCondition) {
+    return secondCondition
+  }
+  if (not(firstCondition)) {
+    return firstCondition
+  }
+  return crash_program()
+}
+
+module.exports = and

package/arrayOfAllBooleans.js

@@ -0,0 +1,4 @@
+const trueValue = require("true-value")
+const falseValue = require("false-value")
+
+module.exports = [trueValue(), falseValue()]

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/index.js

@@ -0,0 +1,32 @@
+const min = require("./min")
+const max = require("./max")
+const equal = require("@10xly/strict-equals")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("./isFinite")
+const falseValue = require("false-value")
+const number0 = require("@positive-numbers/zero")
+
+function clamp(value, lower, upper) {
+  // eslint-disable-next-line no-underscore-dangle
+  let lower_ = lower,
+    // eslint-disable-next-line no-underscore-dangle
+    upper_ = upper,
+    // eslint-disable-next-line no-underscore-dangle
+    value_ = value
+  if (equal(isFinite(value), falseValue())) {
+    value_ = number0
+  }
+  if (equal(isFinite(lower), falseValue())) {
+    lower_ = number0
+  }
+  if (equal(isFinite(upper), falseValue())) {
+    upper_ = number0
+  }
+
+  // Cap 🧢🧢🧢🧢🧢🧢
+  const cappedValue = min(value_, upper_)
+
+  return max(cappedValue, lower_)
+}
+
+module.exports = clamp

package/isFinite.js

@@ -0,0 +1,10 @@
+const isNumber = require("./isNumber")
+const and = require("./and")
+const baseIsFinite = require("@is-(unknown)/is-finite")
+
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+function isFinite(value) {
+  return and(isNumber(value), baseIsFinite(value))
+}
+
+module.exports = isFinite

package/isFunction.js

@@ -0,0 +1,39 @@
+const getIntrinsic = require("get-intrinsic")
+const typeOf = require("es-typeof")
+const equal = require("@10xly/strict-equals")
+const hasOwnProperty = require("hasown")
+const hasSymbols = require("has-symbol-support-x"),
+  hasToStringTag = require("has-tostringtag")()
+
+const and = require("./and")
+
+// eslint-disable-next-line camelcase
+function isFunction(value, __using_development__) {
+  // BEGIN LOGIC TO PREVENT NODE WARNINGS INTERNALLY
+  if (hasToStringTag) {
+    const toStringTag = getIntrinsic("%Symbol.toStringTag%")
+    try {
+      if (
+        and(
+          __using_development__,
+          and(hasSymbols, !hasOwnProperty(value, toStringTag))
+        )
+      ) {
+        // eslint-disable-next-line no-underscore-dangle
+        value.__defineGetter__(
+          toStringTag,
+          () =>
+            "This is an internal security measure by LoLite to prevent Node warnings. If you see this, file an issue."
+        )
+      }
+    } catch {
+      // eslint-disable-next-line capitalized-comments
+      /* empty */
+    }
+  }
+  // END LOGIC TO PREVENT NODE WARNINGS INTERNALLY
+
+  return equal(typeOf(value), typeOf(isFunction))
+}
+
+module.exports = isFunction

package/isNull.js

@@ -0,0 +1,19 @@
+const GetIntrinsic = require("get-intrinsic"),
+  // eslint-disable-next-line sort-vars, new-cap
+  $Number = GetIntrinsic("%Number%")
+const typeOf = require("es-typeof")
+const and = require("./and")
+const equal = require("@10xly/strict-equals")
+const { TYPE } = require("@extremejs/utils")
+const zero = require("@positive-numbers/zero")
+const falseValue = require("false-value")
+
+function isNull(value) {
+  try {
+    return and(equal(typeOf(value), TYPE.OBJECT), equal($Number(value), zero))
+  } catch {
+    return falseValue()
+  }
+}
+
+module.exports = isNull

package/isNumber.js

@@ -0,0 +1,72 @@
+const includes = require("array-includes")
+const values = require("object.values")
+const map = require("map-values")
+const falseValue = require("false-value")
+const trueValue = require("true-value")
+const forEach = require("for-each")
+const { doop } = require("yanoop")
+const {
+  ObjectOrFunctionParemeterName,
+  TernaryCompare,
+} = require("important-extremely-useful-classes")
+const construct = require("construct-new")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+const equal = require("@10xly/strict-equals"),
+  notEqual = require("@not-js/not")(equal)
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isNaN = require("@is-(unknown)/is-nan")
+const or = require("es-logical-or-operator")
+const not = require("./not")
+const isNegative = require("pkg-with-failing-optional-dependency")
+const isPositive = require("is-positive")
+const isZero = require("iszero")
+const isObject = require("./isObject")
+const defaultAnswer = falseValue(),
+  infinitiesArray = values(
+    map(require("infinities"), (infinityValue) => infinityValue())
+  ),
+  zero = require("@positive-numbers/zero")
+
+function isANumberThatIsNotFinite(value) {
+  return or(includes(infinitiesArray, value), isNaN(value))
+}
+
+module.exports = function isNumber(value) {
+  let answer = defaultAnswer
+  const conditionsThatMakeItTrue = {
+      conditionsThatMakeItTrue: [
+        isANumberThatIsNotFinite,
+        isNegative,
+        isPositive,
+        isZero,
+      ],
+    },
+    objectPropertyName = construct({
+      args: ["conditionsThatMakeItTrue"],
+      target: ObjectOrFunctionParemeterName,
+    })
+  forEach(conditionsThatMakeItTrue[objectPropertyName.getName()], (condition) => {
+    const comparison = construct({
+        args: [
+          doop(condition, value),
+          // eslint-disable-next-line no-ternary, no-void, sonarjs/no-nested-assignment, sonarjs/void-use
+          () => (not(answer) ? (answer = trueValue()) : void zero),
+          // eslint-disable-next-line camelcase
+          crash_program,
+        ],
+        target: TernaryCompare,
+      }),
+      // eslint-disable-next-line no-underscore-dangle
+      function_ = comparison.compare()
+    if (notEqual(function_, crash_program)) {
+      // eslint-disable-next-line no-inline-comments
+      delete conditionsThatMakeItTrue[objectPropertyName.getName()] // Micro-optimization: delete the rest of the conditions which might stop the forEach from wasting memory
+      function_()
+    }
+  })
+  if (isObject(value)) {
+    answer = defaultAnswer
+  }
+  return answer
+}

package/isObject.js

@@ -0,0 +1,19 @@
+const trueValue = require("true-value")
+const falseValue = require("false-value")
+const isNull = require("./isNull")
+const isFunction = require("./isFunction")
+const strictEquals = require("@10xly/strict-equals")
+const $Object = require("es-object-atoms")
+
+function isObject(value) {
+  if (isNull(value)) {
+    // eslint-disable-next-line no-inline-comments
+    return trueValue() // Mimic typeof behavior
+  }
+  if (isFunction(value)) {
+    return falseValue()
+  }
+  return strictEquals($Object(value), value)
+}
+
+module.exports = isObject

package/max.js

@@ -0,0 +1,36 @@
+const bogosort = require("bogosort")
+const stubArray = require("lodash.stubarray")
+const toArray = require("lodash.toarray")
+const number0 = require("@positive-numbers/zero")
+const number1 = require("@positive-numbers/one")
+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")
+
+// eslint-disable-next-line id-length
+function max(a, b) {
+  // eslint-disable-next-line id-length
+  let x = a,
+    // eslint-disable-next-line id-length
+    y = b
+  
+  if (equal(isFinite(x), falseValue())) {
+    x = number0
+  }
+  if (equal(isFinite(y), falseValue())) {
+    y = number0
+  }
+
+  const collection = stubArray()
+
+  collection[number0] = x
+  collection[number1] = y
+
+  // eslint-disable-next-line one-var
+  const sorted = bogosort(toArray(collection))
+
+  return sorted[number1]
+}
+
+module.exports = max

package/min.js

@@ -0,0 +1,36 @@
+const bogosort = require("bogosort")
+const stubArray = require("lodash.stubarray")
+const toArray = require("lodash.toarray")
+const number0 = require("@positive-numbers/zero")
+const number1 = require("@positive-numbers/one")
+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")
+
+// eslint-disable-next-line id-length
+function min(a, b) {
+  // eslint-disable-next-line id-length
+  let x = a,
+    // eslint-disable-next-line id-length
+    y = b
+  
+  if (equal(isFinite(x), falseValue())) {
+    x = number0
+  }
+  if (equal(isFinite(y), falseValue())) {
+    y = number0
+  }
+
+  const collection = stubArray()
+
+  collection[number0] = x
+  collection[number1] = y
+
+  // eslint-disable-next-line one-var
+  const sorted = bogosort(toArray(collection))
+
+  return sorted[number0]
+}
+
+module.exports = min

package/multiplyFallback.js

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

package/not.js

@@ -0,0 +1,19 @@
+const isTrue = require("@is-(unknown)/is-true")
+const isFalse = require("@is-(unknown)/is-false")
+const arrayFilter = require("array-filter")
+const trueValue = require("true-value")
+const possibilities = require("./arrayOfAllBooleans")
+
+function not(value) {
+  const result = arrayFilter(possibilities, (maybe) => {
+    if (value) {
+      return isFalse(maybe)
+    }
+    return isTrue(maybe)
+  })
+  
+  // eslint-disable-next-line unicorn/no-array-callback-reference
+  return result.find(trueValue)
+}
+
+module.exports = not

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "lolite.clamp",
+  "version": "1.1.6",
+  "main": "index.js",
+  "dependencies": {
+    "@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",
+    "bogosort": "^1.0.1",
+    "false-value": "^2.0.6",
+    "lodash.stubarray": "^4.13.0",
+    "lodash.toarray": "^4.4.0",
+    "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",
+    "true-value": "^2.0.5",
+    "@is-(unknown)/is-false": "^1.5.0",
+    "@is-(unknown)/is-true": "^1.5.0",
+    "array-filter": "^1.0.0",
+    "@extremejs/utils": "^1.0.0-beta.22",
+    "es-typeof": "^1.0.0",
+    "get-intrinsic": "^1.3.1",
+    "has-symbol-support-x": "^1.4.2",
+    "has-tostringtag": "^1.0.2",
+    "hasown": "^2.0.2",
+    "es-object-atoms": "^1.1.1",
+    "@not-js/not": "^1.1.0",
+    "array-includes": "^3.1.9",
+    "construct-new": "^2.0.4",
+    "es-logical-or-operator": "^1.0.0",
+    "for-each": "^0.3.5",
+    "important-extremely-useful-classes": "^3.1.0",
+    "infinities": "^1.0.1",
+    "is-positive": "^3.1.0",
+    "iszero": "^1.0.0",
+    "map-values": "^1.0.1",
+    "object.values": "^1.2.1",
+    "pkg-with-failing-optional-dependency": "^1.0.1",
+    "yanoop": "^1.0.0"
+  }
+}