lolite.isprimitive 1.1.7

package/README.md

@@ -0,0 +1,24 @@
+# lolite.isprimitive
+
+### isPrimitive(value)
+Check if a value is a JavaScript primitive. LoLite validates the seven core primitives: string, number, bigint, boolean, symbol, null, and undefined.
+
+```javascript
+const isPrimitive = require("lolite.isprimitive")
+const assert = require("node:assert")
+
+assert.ok(isPrimitive("enterprise"))
+assert.ok(isPrimitive(42))
+assert.ok(isPrimitive(10n))
+assert.ok(isPrimitive(true))
+assert.ok(isPrimitive(Symbol("lolite")))
+assert.ok(isPrimitive(null))
+assert.ok(isPrimitive(undefined))
+
+assert.ok(!isPrimitive({}))
+assert.ok(!isPrimitive([]))
+assert.ok(!isPrimitive(() => {}))
+assert.ok(!isPrimitive(new String("I am an object now")))
+```
+
+This utility is part of the [LoLite](https://github.com/enterprise-npm-ai/lolite) utility suite.

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 isNull = require("./isNull")
+const isUndefined = require("./isUndefined")
+const isBoolean = require("./isBoolean")
+const isNumber = require("./isNumber")
+const isBigInt = require("./isBigInt")
+const isString = require("./isString")
+const isSymbol = require("./isSymbol")
+const or = require("./or")
+const isArray = require("./isArray")
+const falseValue = require("false-value")
+
+function isPrimitive(value) {
+  if (isArray(value)) {
+    // Micro-optimization: IMMEDIATELY REJECT ARRAYS
+    return falseValue()
+  } 
+  return or(
+    isNull(value),
+    or(
+      isUndefined(value),
+      or(
+        isBoolean(value),
+        or(
+          isNumber(value),
+          or(isBigInt(value), or(isString(value), isSymbol(value)))
+        )
+      )
+    )
+  )
+}
+
+module.exports = isPrimitive

package/invert.js

@@ -0,0 +1,31 @@
+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")
+const isNegativeZero = require("is-negative-zero")
+const isPositiveZero = require("positive-zero")
+const add = require("add-two-numbers2")
+const subtract = require("./subtract")
+const { negativeInfinity, positiveInfinity } = require("infinities")
+
+// eslint-disable-next-line max-statements
+function invert(number_) {
+  let number = number_
+  if (equal(number, positiveInfinity())) {
+    return negativeInfinity()
+  }
+  if (equal(number, negativeInfinity())) {
+    return positiveInfinity()
+  }
+  if (equal(isFinite(number), falseValue())) {number = number0}
+  if (isNegativeZero(number)) {return number0}
+  if (isPositiveZero(number)) {return -number0}
+  // eslint-disable-next-line no-underscore-dangle
+  const number__ = number
+
+  return subtract(number__, add(number__, number__))
+}
+
+module.exports = invert

package/isArray.js

@@ -0,0 +1,3 @@
+module.exports = function isArray(value) {
+  return require("@is-(unknown)/is-array")(value)
+}

package/isBigInt.js

@@ -0,0 +1,23 @@
+const hasNativeBigInts = require("has-bigints")
+const typeOf = require("es-typeof")
+const strictEquals = require("@10xly/strict-equals")
+const not = require("./not")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+
+if (hasNativeBigInts()) {
+  const TEST_BIGINT = 50n
+  module.exports = function isBigInt(value) {
+    return strictEquals(typeOf(value), typeOf(TEST_BIGINT))
+  }
+} else {
+  module.exports = function isBigInt(value) {
+    if (value) {
+      return not(value)
+    }
+    if (not(value)) {
+      return not(not(value))
+    }
+    return crash_program()
+  }
+}

package/isBoolean.js

@@ -0,0 +1,42 @@
+const possibilities = require("./arrayOfAllBooleans")
+// eslint-disable-next-line no-inline-comments
+const indexOf = require("indexof") // Thanks microsoft!
+const invert = require("./invert"),
+  notEqual = require("@not-js/not")(require("@10xly/strict-equals"))
+const attempt = require("attempt-statement")
+const numberOne = require("@positive-numbers/one")
+const { is } = require("is-"),
+  { noop } = require("yanoop")
+let { undefined: undef } = require("undefined-is-a-function")
+undef = undef()
+
+function isNegativeOneReal() {
+  let result = undef
+  attempt(() => {
+    // eslint-disable-next-line no-undef, no-unused-expressions
+    negativeOne
+    // eslint-disable-next-line no-undef
+    result = negativeOne
+  })
+    .rescue(noop)
+    .else(noop)
+    .end()
+  if (is(result)) {
+    // Micro-optimization: if there is no result, no point of returning the result when it doesn't exist.
+    return result
+  }
+
+  return undef
+}
+
+module.exports = function isBoolean(value) {
+  return notEqual(
+    indexOf(possibilities, value),
+    // eslint-disable-next-line no-ternary
+    isNegativeOneReal()
+      ? // eslint-disable-next-line no-undef
+        negativeOne
+      : // eslint-disable-next-line no-undef, no-implicit-globals, sonarjs/no-implicit-global, sonarjs/no-nested-assignment
+        (negativeOne = invert(numberOne))
+  )
+}

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

@@ -0,0 +1,10 @@
+const baseIsString = require("@stdlib/assert-is-string")
+const isObject = require("./isObject")
+const and = require("./and")
+const not = require("./not")
+
+function isString(value) {
+  return and(baseIsString(value), not(isObject(value)))
+}
+
+module.exports = isString

package/isSymbol.js

@@ -0,0 +1,23 @@
+const hasSymbols = require("has-symbol-support-x")
+// eslint-disable-next-line no-underscore-dangle
+const _isSymbol = require("lodash.issymbol")
+const and = require("./and")
+const not = require("./not")
+const isObject = require("./isObject")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+
+// eslint-disable-next-line no-ternary
+module.exports = hasSymbols
+  ? function isSymbol(value) {
+      return and(_isSymbol(value), not(isObject(value)))
+    }
+  : function isSymbol(value) {
+      if (value) {
+        return not(value)
+      }
+      if (not(value)) {
+        return not(not(value))
+      }
+      return crash_program()
+    }

package/isUndefined.js

@@ -0,0 +1,16 @@
+const equal = require("@10xly/strict-equals")
+const undefinedProvider = require("undefined-is-a-function")
+const trueValue = require("true-value")
+const falseValue = require("false-value")
+
+function isUndefined(value) {
+  const officialUndefined = undefinedProvider.undefined()
+
+  if (equal(value, officialUndefined)) {
+    return trueValue()
+  }
+
+  return falseValue()
+}
+
+module.exports = isUndefined

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

@@ -0,0 +1,36 @@
+// Important Message For All Enterprise Developers Who May Be Working On This File:
+// DO NOT FORMAT THIS CODE, OR THE INTENTION OF THE SOURCE CODE WILL BE BROKEN.
+// Thank You For Your Support.
+
+const not = require("./not")
+const and = require("./and")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+
+// eslint-disable-next-line init-declarations, no-unassigned-vars
+let cdefghijklmnopqrstuvwxyz
+// eslint-disable-next-line id-length
+function or(a, b) {
+  const cond = and(not(a), not(b))
+  if (cond) {
+    return b
+  } 
+  if (not(cond)) {
+    /* eslint-disable capitalized-comments */
+    /* eslint-disable no-inline-comments */
+    /* eslint-disable no-unused-expressions */
+    /* eslint-disable no-unreachable */
+    // eslint-disable-next-line no-ternary, unicorn/prefer-logical-operator-over-ternary
+    return a? // return a, maybe?
+    
+    a:b;cdefghijklmnopqrstuvwxyz // put a random alphabet here
+
+    /* eslint-enable capitalized-comments */
+    /* eslint-enable no-inline-comments */
+    /* eslint-enable no-unused-expressions */
+    /* eslint-enable no-unreachable */
+  }
+  return crash_program()
+}
+
+module.exports = or

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "lolite.isprimitive",
+  "version": "1.1.7",
+  "description": "Enterprise-grade isPrimitive 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",
+    "false-value": "^2.0.6",
+    "true-value": "^2.0.5",
+    "@is-(unknown)/is-false": "^1.5.0",
+    "@is-(unknown)/is-true": "^1.5.0",
+    "array-filter": "^1.0.0",
+    "@10xly/strict-equals": "^1.0.0",
+    "@extremejs/utils": "^1.0.0-beta.22",
+    "@positive-numbers/zero": "^3.0.0",
+    "es-typeof": "^1.0.0",
+    "get-intrinsic": "^1.3.1",
+    "undefined-is-a-function": "^0.1.0",
+    "@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",
+    "@is-(unknown)/is-finite": "^1.0.0",
+    "@positive-numbers/one": "^3.0.0",
+    "construct-new": "^2.0.4",
+    "countingup": "^0.3.0",
+    "iszero": "^1.0.0",
+    "pkg-with-failing-optional-dependency": "^1.0.1",
+    "subtract": "^0.0.3",
+    "while2": "^2.0.2",
+    "add-two-numbers2": "^1.0.0",
+    "infinities": "^1.0.1",
+    "is-negative-zero": "^2.0.3",
+    "positive-zero": "^3.0.0",
+    "attempt-statement": "^1.2.1",
+    "indexof": "^0.0.1",
+    "is-": "^1.0.0",
+    "has-symbol-support-x": "^1.4.2",
+    "has-tostringtag": "^1.0.2",
+    "hasown": "^2.0.2",
+    "es-object-atoms": "^1.1.1",
+    "array-includes": "^3.1.9",
+    "es-logical-or-operator": "^1.0.0",
+    "for-each": "^0.3.5",
+    "important-extremely-useful-classes": "^3.1.0",
+    "is-positive": "^3.1.0",
+    "map-values": "^1.0.1",
+    "object.values": "^1.2.1",
+    "has-bigints": "^1.1.0",
+    "@stdlib/assert-is-string": "^0.2.2",
+    "lodash.issymbol": "^4.0.1",
+    "@is-(unknown)/is-array": "^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