feat(presence): implemented presence function

src/index.js

@@ -164,6 +164,7 @@ export { default as sortByProps } from './sortByProps';
 export { default as skipTake } from './skipTake';
 export { default as rangeStep } from './rangeStep';
 export { default as findOr } from './findOr';
+export { default as presence } from './presence';
 // Object
 export { default as invoke } from './invoke';
 export { default as invokeArgs } from './invokeArgs';

src/presence.js

@@ -0,0 +1,35 @@
+import * as R from 'ramda';
+
+/**
+ * Check if value is empty or undefined then returns null, otherwise, returns itself.
+ *
+ * @func presence
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Object
+ * @sig k -> null | k
+ * @param {k} val The value to test
+ * @return {null | k}
+ * @example
+ *
+ * presence({ foo: 'foo' }) // { foo: 'foo' }
+ * presence({}) // null
+ * presence(false) // null
+ * presence(true) // true
+ * presence('') // null
+ * presence('foo') // foo
+ * presence([]) // null
+ * presence([1, 2, 3]) // [1, 2, 3]
+ * presence(undefined) // null
+ * presence(0) // 0
+ * presence(null) // null
+ */
+
+const presence = R.cond([
+  [R.equals(false), R.always(null)],
+  [R.isEmpty, R.always(null)],
+  [R.isNil, R.always(null)],
+  [R.T, R.identity],
+]);
+
+export default presence;

test/presence.js

@@ -0,0 +1,93 @@
+import { assert } from 'chai';
+
+import * as RA from '../src';
+
+describe.only('presence', function () {
+  context('given an object', function () {
+    specify('should return the object', function () {
+      const foo = { foo: 'foo' };
+
+      assert.strictEqual(RA.presence(foo), foo);
+    });
+  });
+
+  context('given an empty object', function () {
+    specify('should return null', function () {
+      const foo = {};
+
+      assert.strictEqual(RA.presence(foo), null);
+    });
+  });
+
+  context('given a boolean with value false', function () {
+    specify('should return null', function () {
+      const foo = false;
+
+      assert.strictEqual(RA.presence(foo), null);
+    });
+  });
+
+  context('given a boolean with value true', function () {
+    specify('should return boolean true', function () {
+      const foo = true;
+
+      assert.strictEqual(RA.presence(foo), foo);
+    });
+  });
+
+  context('given an empty string', function () {
+    specify('should return null', function () {
+      const foo = '';
+
+      assert.strictEqual(RA.presence(foo), null);
+    });
+  });
+
+  context('given a string', function () {
+    specify('should return the correct string', function () {
+      const foo = 'foo';
+
+      assert.strictEqual(RA.presence(foo), foo);
+    });
+  });
+
+  context('given an empty array', function () {
+    specify('should return null', function () {
+      const foo = [];
+
+      assert.strictEqual(RA.presence(foo), null);
+    });
+  });
+
+  context('given an array with values', function () {
+    specify('should return the array', function () {
+      const foo = [1, 2, 3];
+
+      assert.strictEqual(RA.presence(foo), foo);
+    });
+  });
+
+  context('given an undefined', function () {
+    specify('should return null', function () {
+      const foo = undefined;
+
+      assert.strictEqual(RA.presence(foo), null);
+    });
+  });
+
+  context('given a number', function () {
+    specify('should return number', function () {
+      const foo = 0;
+
+      assert.strictEqual(RA.presence(foo), foo);
+    });
+  });
+
+  context('given a null', function () {
+    specify('should return null', function () {
+      const foo = null;
+
+      assert.strictEqual(RA.presence(foo), foo);
+    });
+  });
+});