@identity-js/identity 1.2.8 → 1.2.10

package/BUG-HISTORY.md

@@ -0,0 +1,91 @@
+# Bug History
+
+```js
+// Believe it or not, Identity.js has had many bugs before.
+// As 10x engineers, we accepted that the simplest things
+// are bound to have discovered bugs at some indeterminable
+// point. This file (BUG-HISTORY.md) documents the history
+// of bugs in the Identity.js ecosystem.
+//
+// Note: some of the histories of these bugs are just copy
+// pasted from LoLite's identity function source code:
+// http://github.com/10xly/lolite/blob/main/src/lib/identity.js
+//
+// Note: The bugs in this list are ordered from past to future, so
+// to see the latest bug, you have to scroll to the bottom.
+//
+// -----------------------------------------------------------------------------------
+//
+// JANUARY 5, 2026 BUGS:
+//
+// On the date of January 5, 2026, a double-bug was patched across Identity.js,
+// vValue, and vRetriever where decimals would coerce to integers. The primary source
+// of the bug was the dependency @_immo/return which was an identity function that was
+// heavily relied on but had a bug where it would run parseInt if the given input was
+// a number. This bug was not found because to save our time and effort we would write
+// our tests with AI (specifically Gemini) but AI didn't write comprehensive enough
+// tests. The bug was discovered when we used a different AI (Copilot) to write more
+// comprehensive tests. However, when this was patched it was discovered that the bug
+// was still in vValue, but only happened 33% of the time for an unknown reason,
+// however a sanity check has already been implemented in vRetriever, and vValue
+// has been removed in Identity.js. So this should never happen, but due to recent bugs
+// and AI not making comprehensive enough tests, there is a slim chance that this could
+// still happen. We want LoLite to be as bug-free as possible, which is why we're
+// implementing this. Our moral of the story is that AI sometimes doesn't write good
+// enough tests.
+//
+// For more information, see these commits:
+//
+// https://github.com/10xly/vValue/commit/ff3ca00591ae8725f68587a5091ecb087a8be0d4
+// https://github.com/10xly/vretriever/commit/86626b2741a9f03e19af7e3bae9b8f88e817220c
+// https://github.com/10xly/identityjs/commit/3dfa642bfa9a35b791236f7bd620cb2564bc7780
+//
+// -----------------------------------------------------------------------------------
+//
+// JANUARY 6, 2026 BUGS:
+//
+// On January 6, 2026, another bug was discovered in vValue because the
+// patch for the previous bug regarding floats made use of the package is-float, and
+// its code coerces the value passed in (n) with +n. However, this creates an issue:
+// If you pass a Symbol into this function, you get a TypeError from JS, that looks
+// like this:
+//
+// Uncaught TypeError: Cannot convert a Symbol value to a number
+//
+// That's because JavaScript's stupidity doesn't let you type-coerce Symbols.
+// Since the patch for vValue used is-float, if you tried to pass a Symbol into
+// vValue, it would throw an error, so it would throw the error if you passed it
+// into vRetriever (which depends on vValue), and for Identity.js (depends on
+// vRetriever). This bug was once again not found during the implementation due
+// to AI not writing good-enough tests (this time it was also partially Copilot).
+// This bug was discovered when Copilot randomly decided to write better tests
+// for the constant function in LoLite which includes the identity function.
+// The issue was fixed by wrapping the call to isFloat with a try-catch statement.
+// Moral of the story again: AI sometimes doesn't write good-enough tests.
+// This is why we are thinking about creating our own AI that will ALWAYS write sufficient
+// tests. If you find our tests to be insufficient, please report an issue - AI generated
+// them, so it's AI's fault. As 10x Developers, we all have to accept these things just
+// as side-effects of true Enterprise Development.
+//
+// For more information, see these commits:
+//
+// https://github.com/10xly/vValue/commit/f6f60798d98f52adefbda2b7f525d962752f29dd
+// https://github.com/10xly/vretriever/commit/ff9fd93f7158167303b8fd870211a82c2b269c0b
+// https://github.com/10xly/identityjs/commit/340cc78e6cd5e817d0b784d902f06afdd103769d
+// https://github.com/10xly/identityjs/commit/a520a1d73c653adb41cc5fe317e1e7246b0f96bf
+//
+// -----------------------------------------------------------------------------------
+//
+// FEBRUARY 7, 2026 BUGS:
+//
+// On February 7, 2026, a bug was discovered in Identity.js where it would return 0
+// when passed in -0. This was probably due to @negative-numbers/ identity not being
+// implemented in @identity-js/number-identity and/or 0 being equal to -0 in JavaScript.
+// This bug was fixed by adding a simple Object.is() check to the top of the base identity
+// function.
+//
+// https://github.com/10xly/identityjs/commit/ed7b548ca8bbc72c18f3e2fd2130e23d64a0c7ab
+//
+// -----------------------------------------------------------------------------------
+//
+```

package/index.js

@@ -11,13 +11,25 @@ var isFinite = require("@is-(unknown)/is-finite")
 var isString = require("@is-(unknown)/is-string")
 var asyncUtilIdentity = require("async.util.identity")
 var id = require("js-id")
+var meta2Identity = require("./meta2")
+var isNegativeZero = require("@is-(unknown)/is-negative-zero")
+var isPositiveOrNegativeZero = require("iszero")
+var isNotPositiveOrNegativeZero = require("@not-js/not")(
+  isPositiveOrNegativeZero,
+)
+var and = require("es-logical-and-operator")
+var isNil = require("@not-js/not")(require("@primitive/is-value").isValue)
+var isEq = require("@10xly/strict-equals")
+var isNotEq = require("@not-js/not")(isEq)
 
 function identityCore(value) {
   if (isString(value)) {
     return stringIdentity(value)
   } else if (isFinite(value)) {
     var result = numberIdentity(value)
-    if (result === 0 && value !== 0) {
+    if (
+      and(isPositiveOrNegativeZero(result), isNotPositiveOrNegativeZero(value))
+    ) {
       return value
     } else {
       return result
@@ -28,18 +40,36 @@ function identityCore(value) {
 }
 
 function identity(value) {
-  if (value === null || value === undefined) {
+  try {
+    if (isNegativeZero(value)) {
+      return require("@negative-numbers/zero")
+    }
+    if (isNil(value)) {
+      return value
+    }
+    var result = meta2Identity(
+      identityfunction(
+        vretriever.retrieve(
+          isuseless(
+            id(
+              asyncUtilIdentity(
+                stdlibIdentity(fIdentity(lodashIdentity(identityCore(value)))),
+              ),
+            ),
+            falsevalue,
+            falsevalue,
+          ),
+        ),
+      ),
+    )
+    if (isNotEq(value, result)) {
+      isNotEq.sdfsfdsfs.fsdfsfsdfs.dfdsfsdfs
+    } else {
+      return result
+    }
+  } catch {
     return value
   }
-  return identityfunction(
-    vretriever.retrieve(
-      isuseless(
-        id(asyncUtilIdentity(stdlibIdentity(fIdentity(lodashIdentity(identityCore(value)))))),
-        falsevalue,
-        falsevalue
-      )
-    )
-  )
 }
 
 module.exports = identity

package/meta2.js

@@ -0,0 +1,38 @@
+const identityFunctions = [
+  require("@-ft/i").I,
+  require("return-value").returnValue,
+  require("@identity-js/identity"),
+  require("identity-function"),
+  require("lolite.identity"),
+  require("lodash.identity"),
+  require("ramda.identity"),
+  require("@ramda/identity"),
+  require("lodash").identity,
+  require("@elastic/lodash").identity,
+  require("underscore").identity,
+  require("ramda").identity,
+  require("remeda").identity(),
+  require("es-toolkit").identity,
+  require("basic-functions").echo,
+  require("basic-functions").return,
+  require("empty_function").thatReturnsArgument,
+  require("@nathanfaucett/empty_function").thatReturnsArgument,
+  require("vretriever").retrieve,
+  require("@f/identity"),
+  require("@stdlib/utils-identity-function"),
+  require("async.util.identity"),
+  require("identity-function"),
+  require("js-id"),
+  require("./primitive")
+]
+
+function identity(x) {
+  for (const fn of identityFunctions) {
+    if ((require("lodash").stubObject()).constructor.is(fn(x), x)) {
+      x = fn(x)
+    }
+  }
+  return x
+}
+
+module.exports = identity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@identity-js/identity",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "Returns the value passed into the function.",
   "keywords": [
     "identity-js"
@@ -21,18 +21,44 @@
     "test": "mocha test/index.js"
   },
   "dependencies": {
+    "@-ft/c": "^0.1.0",
+    "@-ft/i": "^0.1.0",
+    "@-ft/noop": "^0.1.0",
+    "@10xly/strict-equals": "^1.0.1",
+    "@elastic/lodash": "^3.10.1-kibana4",
     "@f/identity": "^1.1.1",
-    "@identity-js/number-identity": "^1.2.2",
+    "@identity-js/identity": "^1.2.9",
+    "@identity-js/number-identity": "^1.2.3",
     "@identity-js/string-identity": "^1.1.3",
     "@is-(unknown)/is-finite": "^1.0.0",
+    "@is-(unknown)/is-negative-zero": "^1.0.0",
     "@is-(unknown)/is-string": "^1.0.0",
-    "@stdlib/utils-identity-function": "^0.2.2",
+    "@nathanfaucett/empty_function": "^0.0.1",
+    "@nathanfaucett/is_primitive": "^0.0.2",
+    "@negative-numbers/zero": "^1.0.0",
+    "@not-js/not": "^1.1.1",
+    "@primitive/is-value": "^1.1.0",
+    "@ramda/identity": "^0.26.1",
+    "@stdlib/utils-identity-function": "^0.2.3",
     "async.util.identity": "^0.5.2",
+    "basic-functions": "^1.0.6",
+    "empty_function": "^0.0.1",
+    "es-logical-and-operator": "^1.0.0",
+    "es-toolkit": "^1.44.0",
     "false-value": "^2.0.1",
     "identity-function": "^1.0.0",
     "is-useless": "1.3.4",
+    "iszero": "^1.0.0",
     "js-id": "^1.0.0",
+    "lodash": "^4.17.23",
     "lodash.identity": "^3.0.0",
+    "lolite.identity": "^1.1.17",
+    "primitive-identity-function": "^1.0.0",
+    "ramda": "^0.32.0",
+    "ramda.identity": "^0.26.1",
+    "remeda": "^2.33.5",
+    "return-value": "^1.0.5",
+    "underscore": "^1.13.7",
     "vretriever": "^1.1.4"
   },
   "devDependencies": {

package/primitive.js

@@ -0,0 +1,10 @@
+var isPrimitive = require("@nathanfaucett/is_primitive")
+var primitiveIdentity = require("primitive-identity-function")
+
+module.exports = function identityPrimitiveSafe(x) {
+  if (isPrimitive(x)) {
+    return primitiveIdentity(x)
+  } else {
+    return x
+  }
+}

package/test/index.js

@@ -1,52 +1,147 @@
-const assert = require('chai').assert
-const identity = require('../index')
+const assert = require("chai").assert
+const identity = require("../index")
 
-describe('identity()', () => {
-
-  it('should return the same number that was passed in', () => {
+describe("identity()", () => {
+  it("should return the same number that was passed in", () => {
     const input = 42
-    assert.strictEqual(identity(input), 42, 'The function should return the number 42.')
+    assert.strictEqual(identity(input), 42, "The function should return the number 42.")
   })
 
-  it('should return the same decimal that was passed in', () => {
+  it("should return the same decimal that was passed in", () => {
     const input = 3.2
     assert.strictEqual(identity(input), 3.2, "The function should return 3.2")
   })
+
+  it("should return the same negative number that was passed in", () => {
+    const input = -5
+    assert.strictEqual(identity(input), -5, "The function should return the number -5.")
+  })
+
+  it("should return -0 when -0 is passed in", () => {
+    const input = -0
+    const result = identity(input)
+    assert.strictEqual(result, -0, "The function should return -0.")
+    assert.isTrue(Object.is(result, -0), "The function should return the exact value of -0.")
+  })
   
-  it('should return the same string that was passed in', () => {
-    const input = 'hello world'
-    assert.strictEqual(identity(input), 'hello world', 'The function should return the string "hello world".')
+  it("should return the same string that was passed in", () => {
+    const input = "hello world"
+    assert.strictEqual(identity(input), "hello world", 'The function should return the string "hello world".')
   })
 
-  it('should return the same object reference that was passed in', () => {
-    const inputObject = { a: 1, b: 'test' }
+  it("should return an empty string", () => {
+    assert.strictEqual(identity(""), "")
+  })
+
+  it("should return the same object reference that was passed in", () => {
+    const inputObject = { a: 1, b: "test" }
     const result = identity(inputObject)
-    assert.strictEqual(result, inputObject, 'The function should return the exact same object reference.')
-    assert.deepEqual(result, { a: 1, b: 'test' }, 'The object content should be the same.')
+    assert.strictEqual(result, inputObject, "The function should return the exact same object reference.")
+    assert.deepEqual(result, { a: 1, b: "test" }, "The object content should be the same.")
   })
 
-  it('should return the same boolean value (true)', () => {
+  it("should return the same boolean value (true)", () => {
     const input = true
-    assert.strictEqual(identity(input), true, 'The function should return the boolean true.')
+    assert.strictEqual(identity(input), true, "The function should return the boolean true.")
   })
 
-  it('should return null when null is passed in', () => {
+  it("should return the same boolean value (false)", () => {
+    assert.strictEqual(identity(false), false)
+  })
+
+  it("should return null when null is passed in", () => {
     const input = null
-    assert.strictEqual(identity(input), null, 'The function should return null.')
+    assert.strictEqual(identity(input), null, "The function should return null.")
   })
 
-  it('should return undefined when undefined is passed in', () => {
+  it("should return undefined when undefined is passed in", () => {
     const input = undefined
-    assert.strictEqual(identity(input), undefined, 'The function should return undefined.')
+    assert.strictEqual(identity(input), undefined, "The function should return undefined.")
   })
 
-  it('should return NaN when NaN is passed in', () => {
+  it("should return NaN when NaN is passed in", () => {
     const input = NaN
     assert.isNaN(identity(input), "The function should return NaN")
   })
 
-  it('should return Infinity when Infinity is passed in', () => {
+  it("should return Infinity when Infinity is passed in", () => {
     const input = Infinity
     assert.strictEqual(identity(input), Infinity, "The function should return infinity")
   })
+
+  it("should return -Infinity", () => {
+    assert.strictEqual(identity(-Infinity), -Infinity)
+  })
+
+  it("should return the same BigInt", () => {
+    const input = BigInt(9007199254740991)
+    assert.strictEqual(identity(input), input)
+  })
+
+  it("should return the same Symbol", () => {
+    const sym = Symbol("foo")
+    assert.strictEqual(identity(sym), sym)
+  })
+
+  it("should return the same array reference", () => {
+    const arr = [1, 2, 3]
+    assert.strictEqual(identity(arr), arr)
+  })
+
+  it("should return the same function reference", () => {
+    const fn = (x) => x
+    assert.strictEqual(identity(fn), fn)
+  })
+
+  it("should return the same Date object reference", () => {
+    const date = new Date()
+    assert.strictEqual(identity(date), date)
+  })
+
+  it("should return the same RegExp object reference", () => {
+    const re = /abc/g
+    assert.strictEqual(identity(re), re)
+  })
+
+  it("should return the same Map reference", () => {
+    const map = new Map()
+    assert.strictEqual(identity(map), map)
+  })
+
+  it("should return the same Set reference", () => {
+    const set = new Set()
+    assert.strictEqual(identity(set), set)
+  })
+
+  it("should return the same TypedArray reference", () => {
+    const buffer = new Int8Array(8)
+    assert.strictEqual(identity(buffer), buffer)
+  })
+
+  it("should return the same error object", () => {
+    const err = new Error("fail")
+    assert.strictEqual(identity(err), err)
+  })
+
+  it("should return the same arguments object", function () {
+    assert.strictEqual(identity(arguments), arguments)
+  })
+
+  it("should return the same class reference", () => {
+    class Test {}
+    assert.strictEqual(identity(Test), Test)
+  })
+
+  it("should handle objects with custom valueOf or toString", () => {
+    const obj = {
+      valueOf: () => 10,
+      toString: () => "custom"
+    }
+    assert.strictEqual(identity(obj), obj)
+  })
+
+  it("should return a promise reference without resolving it", () => {
+    const promise = Promise.resolve(true)
+    assert.strictEqual(identity(promise), promise)
+  })
 })