@identity-js/identity 1.2.12 → 1.3.0

package/README.md

@@ -4,7 +4,7 @@ Introducing Identity.js, the 10x identity function.
 
 The identity function, $I(x)$, is a mathematical function that always returns the same value that was used as its argument, i.e., $I(x) = x$. This utility is often used in functional programming paradigms.
 
-At [10x'ly](https://10xengineersqualityprogramming.github.io), we are always looking for new opportunities to make 10x libraries and then it struck us: what about an identity function? This package spreads **10x'ness** into the simple concept of an identity function. It's not just an identity function, it's a **10x identity function**.
+At 10x'ly made, we are always looking for new opportunities to make 10x libraries and then it struck us: what about an identity function? This package spreads **10x'ness** into the simple concept of an identity function. It's not just an identity function, it's a **10x identity function**.
 
 ## 💾 Installation
 
@@ -18,20 +18,22 @@ npm install @identity-js/identity
 
 The function accepts a single argument of any type and returns that argument unchanged.
 
-### Importing
+```javascript
+const identity = require("@identity-js/identity")
+```
+
+Identity.js also has an unstable version that uses deasyncing `Promise.resolve`. It is called unstable because this is a weird hack. You can use it instead if you want:
 
 ```javascript
-const identity = require("@identity-js/identity"); 
+const identity = require("@identity-js/identity/unstable")
 ```
 
-### Examples
+Then you can just call it with a value and it will return that value:
+```javascript
+const identity = require("@identity-js/identity")
 
-| Input Type | Code | Output |
-| :--- | :--- | :--- |
-| **Number** | `identity(42)` | `42` |
-| **String** | `identity('hello')` | `'hello'` |
-| **Object** | `const obj = {a: 1}; identity(obj)` | `// returns the same object reference: {a: 1}` |
-| **Null** | `identity(null)` | `null` |
+console.log(identity("hello world")) // "hello world"
+```
 
 ## ✅ Testing
 

package/index.d.ts

@@ -0,0 +1,3 @@
+declare function identity<T>(x: T): T
+
+export = identity

package/index.js

@@ -1,75 +1 @@
-var stringIdentity = require("@identity-js/string-identity")
-var numberIdentity = require("@identity-js/number-identity")
-var lodashIdentity = require("lodash.identity")
-var fIdentity = require("@f/identity")
-var stdlibIdentity = require("@stdlib/utils-identity-function")
-var vretriever = require("vretriever")
-var isuseless = require("is-useless").isuseless
-var falsevalue = require("false-value")()
-var identityfunction = require("identity-function")
-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 (
-      and(isPositiveOrNegativeZero(result), isNotPositiveOrNegativeZero(value))
-    ) {
-      return value
-    } else {
-      return result
-    }
-  } else {
-    return value
-  }
-}
-
-function identity(value) {
-  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
-  }
-}
-
-module.exports = identity
+module.exports = require("./lib")

package/lib/core.js

@@ -0,0 +1,83 @@
+function createIdentity(meta2Identity) {
+  var stringIdentity = require("@identity-js/string-identity")
+  var numberIdentity = require("@identity-js/number-identity")
+  var lodashIdentity = require("lodash.identity")
+  var fIdentity = require("@f/identity")
+  var stdlibIdentity = require("@stdlib/utils-identity-function")
+  var vretriever = require("vretriever")
+  var isuseless = require("is-useless").isuseless
+  var falsevalue = require("false-value")()
+  var identityfunction = require("identity-function")
+  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 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 (
+        and(
+          isPositiveOrNegativeZero(result),
+          isNotPositiveOrNegativeZero(value),
+        )
+      ) {
+        return value
+      } else {
+        return result
+      }
+    } else {
+      return value
+    }
+  }
+
+  function identity(value) {
+    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 identity
+}
+
+module.exports = createIdentity

package/lib/coremeta2.js

@@ -0,0 +1,14 @@
+function createMeta2(identityFunctions) {
+  function identity(x) {
+    for (const fn of identityFunctions) {
+      if (require("lodash").stubObject().constructor.is(fn(x), x)) {
+        x = fn(x)
+      }
+    }
+    return x
+  }
+
+  return identity
+}
+
+module.exports = createMeta2

package/lib/index.js

@@ -0,0 +1 @@
+module.exports = require("./core")(require("./meta2"))

package/lib/meta2.js

@@ -0,0 +1,3 @@
+const createMeta2 = require("./coremeta2")
+
+module.exports = createMeta2(require("./meta2IdentityFunctions"))

package/{meta2.js → lib/meta2IdentityFunctions.js}

@@ -1,9 +1,7 @@
-const identityFunctions = [
+module.exports = [
   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"),
@@ -23,16 +21,5 @@ const identityFunctions = [
   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
+  require("./primitive"),
+]

package/lib/meta2IdentityFunctionsUnstable.js

@@ -0,0 +1,3 @@
+var identityFunctions = require("./meta2IdentityFunctions")
+
+module.exports = identityFunctions.concat(require("./syncResolve"))

package/lib/meta2Unstable.js

@@ -0,0 +1,3 @@
+const createMeta2 = require("./coremeta2")
+
+module.exports = createMeta2(require("./meta2IdentityFunctionsUnstable"))

package/lib/syncResolve.js

@@ -0,0 +1,8 @@
+const $Promise = require("is-a-promise")
+const deasync = require("deasync")
+const call = require("node-call.then")
+const NULL = require("primitive-value-null")
+
+module.exports = deasync(function(val, cb) {
+  call.then($Promise.resolve(val), res => cb(NULL, res))
+})

package/lib/unstable.js

@@ -0,0 +1 @@
+module.exports = require("./core")(require("./meta2Unstable"))

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@identity-js/identity",
-  "version": "1.2.12",
+  "version": "1.3.0",
   "description": "Returns the value passed into the function.",
   "keywords": [
-    "identity-js"
+    "identity-js",
+    "10xly",
+    "jsfruit",
+    "identity",
+    "lolite"
   ],
   "homepage": "https://github.com/10xly/identityjs#readme",
   "bugs": {
@@ -40,18 +44,22 @@
     "@stdlib/utils-identity-function": "^0.2.3",
     "async.util.identity": "^0.5.2",
     "basic-functions": "^1.0.6",
+    "deasync": "^0.1.31",
     "empty_function": "^0.0.1",
     "es-logical-and-operator": "^1.0.0",
     "es-to-primitive": "1.3.0",
     "es-toolkit": "^1.44.0",
     "false-value": "^2.0.1",
     "identity-function": "^1.0.0",
+    "is-a-promise": "^0.1.0",
     "is-useless": "1.3.4",
     "iszero": "^1.0.0",
     "js-id": "^1.0.0",
     "lodash": "^4.17.23",
     "lodash.identity": "^3.0.0",
+    "node-call.then": "^1.0.0",
     "primitive-identity-function": "^1.0.0",
+    "primitive-value-null": "^1.0.0",
     "ramda": "^0.32.0",
     "ramda.identity": "^0.26.1",
     "remeda": "^2.33.5",

package/test/index.js

@@ -1,147 +1,192 @@
 const assert = require("chai").assert
-const identity = require("../index")
-
-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.")
-  })
-
-  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 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.")
-  })
-
-  it("should return the same boolean value (true)", () => {
-    const input = true
-    assert.strictEqual(identity(input), true, "The function should return the boolean true.")
-  })
-
-  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.")
-  })
-
-  it("should return undefined when undefined is passed in", () => {
-    const input = undefined
-    assert.strictEqual(identity(input), undefined, "The function should return undefined.")
-  })
-
-  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", () => {
-    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)
-  })
-})
+const identityStable = require("../index")
+const identityUnstable = require("../unstable")
+
+function testIdentity(identity) {
+  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.",
+      )
+    })
+
+    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 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.",
+      )
+    })
+
+    it("should return the same boolean value (true)", () => {
+      const input = true
+      assert.strictEqual(
+        identity(input),
+        true,
+        "The function should return the boolean true.",
+      )
+    })
+
+    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.",
+      )
+    })
+
+    it("should return undefined when undefined is passed in", () => {
+      const input = undefined
+      assert.strictEqual(
+        identity(input),
+        undefined,
+        "The function should return undefined.",
+      )
+    })
+
+    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", () => {
+      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)
+    })
+  })
+}
+
+testIdentity(identityStable)
+testIdentity(identityUnstable)

package/unstable.d.ts

@@ -0,0 +1,3 @@
+declare function identity<T>(x: T): T
+
+export = identity

package/unstable.js

@@ -0,0 +1 @@
+module.exports = require("./lib/unstable")