refactor: remove ramda from textkit package (diegomura#1830)

Author: diegomura

adjust.js

@@ -0,0 +1,10 @@
+const adjust = (index, fn, collection) => {
+  if (index >= 0 && index >= collection.length) return collection;
+  if (index < 0 && Math.abs(index) > collection.length) return collection;
+
+  const i = index < 0 ? collection.length + index : index;
+
+  return Object.assign([], collection, { [i]: fn(collection[i]) });
+};
+
+export default adjust;

adjust.test.js

@@ -0,0 +1,32 @@
+import adjust from './adjust';
+
+const add = v => v + 1;
+
+describe('adjust', () => {
+  test('applies the given function to the value at the given index of the supplied array', () => {
+    const expected = [0, 1, 3, 3];
+    const result = adjust(2, add, [0, 1, 2, 3]);
+
+    expect(result).toEqual(expected);
+  });
+
+  test('offsets negative indexes from the end of the array', () => {
+    const expected = [0, 2, 2, 3];
+    const result = adjust(-3, add, [0, 1, 2, 3]);
+
+    expect(result).toEqual(expected);
+  });
+
+  test('returns the original array if the supplied index is out of bounds', () => {
+    const expected = [0, 1, 2, 3];
+
+    expect(adjust(4, add, expected)).toBe(expected);
+    expect(adjust(-5, add, expected)).toBe(expected);
+  });
+
+  test('does not mutate the original array', () => {
+    const expected = [0, 1, 2, 3];
+    adjust(2, add, expected);
+    expect([0, 1, 2, 3]).toEqual(expected);
+  });
+});

dropLast.js

@@ -0,0 +1,3 @@
+const dropLast = array => array.slice(0, array.length - 1);
+
+export default dropLast;

dropLast.test.js

@@ -0,0 +1,19 @@
+import dropLast from './dropLast';
+
+describe('dropLast', () => {
+  test('skips the last element from a list, returning the remainder', () => {
+    expect(dropLast(['a', 'b', 'c', 'd'])).toEqual(['a', 'b', 'c']);
+  });
+
+  test('returns an empty array if passed 1 element array', () => {
+    expect(dropLast(['a'])).toEqual([]);
+  });
+
+  test('returns an empty array if passed empty array', () => {
+    expect(dropLast([])).toEqual([]);
+  });
+
+  test('can operate on strings', () => {
+    expect(dropLast('react-pdf')).toEqual('react-pd');
+  });
+});

evolve.js

@@ -0,0 +1,20 @@
+const evolve = (transformations, object) => {
+  const result = object instanceof Array ? [] : {};
+  const keys = Object.keys(object);
+
+  for (let i = 0; i < keys.length; i += 1) {
+    const key = keys[i];
+    const transformation = transformations[key];
+    const type = typeof transformation;
+
+    if (type === 'function') {
+      result[key] = transformation(object[key]);
+    } else if (transformation && type === 'object') {
+      result[key] = evolve(transformation, object[key]);
+    } else result[key] = object[key];
+  }
+
+  return result;
+};
+
+export default evolve;

get.js

@@ -0,0 +1,20 @@
+import isNil from './isNil';
+import castArray from './castArray';
+
+const get = (target, path, defaultValue) => {
+  if (isNil(target)) return defaultValue;
+
+  const _path = castArray(path);
+
+  let result = target;
+
+  for (let i = 0; i < _path.length; i += 1) {
+    if (isNil(result)) return undefined;
+
+    result = result[_path[i]];
+  }
+
+  return isNil(result) ? defaultValue : result;
+};
+
+export default get;

get.test.js

@@ -0,0 +1,57 @@
+import get from './get';
+
+describe('get', () => {
+  const deepObject = {
+    a: { b: { c: 'c' } },
+    falseVal: false,
+    nullVal: null,
+    undefinedVal: undefined,
+    arrayVal: ['arr'],
+  };
+
+  test('takes a path and an object and returns the value at the path or the default value', () => {
+    const obj = {
+      a: {
+        b: {
+          c: 100,
+          d: 200,
+        },
+        e: {
+          f: [100, 101, 102],
+          g: 'G',
+        },
+        h: 'H',
+      },
+      i: 'I',
+      j: ['J'],
+    };
+
+    expect(get(obj, ['a', 'b', 'c'], 'Unknown')).toBe(100);
+    expect(get(obj, [], 'Unknown')).toBe(obj);
+    expect(get(obj, ['a', 'e', 'f', 1], 'Unknown')).toBe(101);
+    expect(get(obj, ['j', 0], 'Unknown')).toBe('J');
+    expect(get(obj, ['j', 1], 'Unknown')).toBe('Unknown');
+    expect(get(null, ['a', 'b', 'c'], 'Unknown')).toBe('Unknown');
+  });
+
+  test("gets a deep property's value from objects", () => {
+    expect(get(deepObject, ['a', 'b', 'c'], 'Unknown')).toBe('c');
+    expect(get(deepObject, ['a'], 'Unknown')).toBe(deepObject.a);
+  });
+
+  test('returns the default value for items not found', () => {
+    expect(get(deepObject, ['a', 'b', 'foo'], 'Unknown')).toBe('Unknown');
+    expect(get(deepObject, ['bar'], 'Unknown')).toBe('Unknown');
+  });
+
+  test('returns the default value for null/undefined', () => {
+    expect(get(null, ['toString'], 'Unknown')).toBe('Unknown');
+    expect(get(undefined, ['toString'], 'Unknown')).toBe('Unknown');
+  });
+
+  test('works with falsy items', () => {
+    expect(get(false, ['toString'], 'Unknown')).toBe(
+      Boolean.prototype.toString,
+    );
+  });
+});

isNil.js

@@ -0,0 +1,3 @@
+const isNil = value => value === null || value === undefined;
+
+export default isNil;

isNil.test.js

@@ -0,0 +1,14 @@
+/* eslint-disable no-void */
+
+import isNil from './isNil';
+
+describe('isNil', () => {
+  test('tests a value for `null` or `undefined`', () => {
+    expect(isNil(void 0)).toBe(true);
+    expect(isNil(null)).toBe(true);
+    expect(isNil([])).toBe(false);
+    expect(isNil({})).toBe(false);
+    expect(isNil(0)).toBe(false);
+    expect(isNil('')).toBe(false);
+  });
+});

last.js

@@ -0,0 +1,5 @@
+const last = value => {
+  return value === '' ? '' : value[value.length - 1];
+};
+
+export default last;