feat(utils): include getters and setters utils

Author: assisrafael

src/utils/getters-setters.js

@@ -0,0 +1,59 @@
+export function splitPath(path) {
+  return path
+    .replace(/]/g, '')
+    .split(/[.[]/)
+    .map((path, index, paths) => {
+      const def = { path };
+
+      if (parseInt(paths[index + 1], 10).toString() === paths[index + 1]) {
+        def.couldBeAnArray = true;
+      }
+
+      return def;
+    });
+}
+
+export function getValueByPath(obj, objPath) {
+  const paths = splitPath(objPath);
+
+  return paths.reduce((cursor, { path }) => {
+    if (typeof cursor === 'undefined') {
+      return;
+    }
+
+    if (!path) {
+      return cursor;
+    }
+
+    return cursor[path];
+  }, obj);
+}
+
+export function setValueByPath(obj, objPath, value) {
+  const paths = splitPath(objPath);
+
+  if (paths.length === 1) {
+    obj[objPath] = value;
+
+    return obj;
+  }
+
+  const { path: lastPath } = paths[paths.length - 1];
+  const remainingPaths = paths.slice(0, paths.length - 1);
+
+  const lastCursor = remainingPaths.reduce((cursor, { path, couldBeAnArray }) => {
+    if (!path) {
+      return cursor || (couldBeAnArray ? [] : {});
+    }
+
+    if (!cursor[path]) {
+      cursor[path] = couldBeAnArray ? [] : {};
+    }
+
+    return cursor[path];
+  }, obj);
+
+  lastCursor[lastPath] = value;
+
+  return obj || lastCursor;
+}

test/getters-setters.test.js

@@ -0,0 +1,48 @@
+import { setValueByPath, getValueByPath, splitPath } from '../src/utils/getters-setters';
+
+test('splitPath should split path strings into hierarchical components', () => {
+  expect(splitPath('a.b.0.c')).toStrictEqual([
+    { path: 'a' },
+    { path: 'b', couldBeAnArray: true },
+    { path: '0' },
+    { path: 'c' },
+  ]);
+  expect(splitPath('a.b[0].c.d')).toStrictEqual([
+    { path: 'a' },
+    { path: 'b', couldBeAnArray: true },
+    { path: '0' },
+    { path: 'c' },
+    { path: 'd' },
+  ]);
+  expect(splitPath('a[0].b[2].c[3].d')).toStrictEqual([
+    { path: 'a', couldBeAnArray: true },
+    { path: '0' },
+    { path: 'b', couldBeAnArray: true },
+    { path: '2' },
+    { path: 'c', couldBeAnArray: true },
+    { path: '3' },
+    { path: 'd' },
+  ]);
+});
+
+test('setValueByPath should set values inside complex objects', () => {
+  expect(setValueByPath({}, 'a', 4)).toStrictEqual({ a: 4 });
+  expect(setValueByPath({}, 'a.b', 5)).toStrictEqual({ a: { b: 5 } });
+  expect(setValueByPath({}, 'a[0]', 6)).toStrictEqual({ a: [6] });
+  expect(setValueByPath({ a: {} }, 'a[0]', 6)).toStrictEqual({ a: { '0': 6 } });
+  expect(setValueByPath({}, 'a[0].b', 6)).toStrictEqual({ a: [{ b: 6 }] });
+  expect(setValueByPath({}, '[1]', 'abc')).toStrictEqual({ '1': 'abc' });
+  // eslint-disable-next-line no-sparse-arrays
+  expect(setValueByPath(null, '[1]', 'abc')).toStrictEqual([, 'abc']);
+});
+
+test('getValueByPath should get path value of complex objects', () => {
+  expect(getValueByPath({}, 'a')).toBe(undefined);
+  expect(getValueByPath({}, '[0]')).toBe(undefined);
+  expect(getValueByPath([1, 'h'], '[1]')).toBe('h');
+  expect(getValueByPath([{ a: 'h' }], '[0].a')).toBe('h');
+  expect(getValueByPath({}, 'a.b')).toBe(undefined);
+  expect(getValueByPath({ a: [6] }, 'a[0]')).toBe(6);
+  expect(getValueByPath({ a: { '0': 6 } }, 'a[0]')).toBe(6);
+  expect(getValueByPath({ a: [2, { b: [3, 4, 5, { c: { d: 'efg' } }] }] }, 'a[1].b.3.c')).toStrictEqual({ d: 'efg' });
+});