@thecb/components 5.0.0-beta.6 → 5.0.0-beta.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thecb/components",
-  "version": "5.0.0-beta.6",
+  "version": "5.0.0-beta.9",
   "description": "Common lib for CityBase react components",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
@@ -21,6 +21,7 @@
   "homepage": "https://github.com/CityBaseInc/cb-components#readme",
   "devDependencies": {
     "@babel/core": "^7.0.0-0",
+    "@babel/eslint-parser": "^7.15.8",
     "@babel/preset-env": "^7.6.0",
     "@babel/preset-react": "^7.0.0",
     "@babel/register": "^7.6.2",
@@ -34,7 +35,6 @@
     "@storybook/addon-viewport": "^5.3.14",
     "@storybook/react": "^5.3.14",
     "babel-core": "^6.26.3",
-    "babel-eslint": "^10.1.0",
     "babel-loader": "^8.1.0",
     "babel-preset-env": "^1.7.0",
     "babel-preset-react": "^6.24.1",
@@ -73,6 +73,7 @@
     }
   },
   "dependencies": {
+    "@babel/runtime": "^7.15.4",
     "formatted-input": "^0.1.3",
     "framer-motion": "^1.11.0",
     "numeral": "^2.0.6",

package/src/deprecated/utility/__tests__/safeConcat.spec.js

@@ -1,59 +1,61 @@
-//      
+//
 
-import safeConcat from '../safeConcat';
+import safeConcat from "../safeConcat";
 
-describe('safeConcat', () => {
+describe("safeConcat", () => {
   beforeEach(() => {
     console.error = jest.fn();
   });
 
-  describe('arg validation', () => {
-    describe('when values not an array', () => {
-      it('throws console error', () => {
-        const result = safeConcat('a', '-');
+  describe("arg validation", () => {
+    describe("when values not an array", () => {
+      it("throws console error", () => {
+        const result = safeConcat("a", "-");
 
         const errors = console.error.mock.calls;
         expect(errors.length).toEqual(1);
 
         const firstError = errors[0][0];
-        expect(firstError).toEqual('\'values\' needs to be an array. Recieved string');
+        expect(firstError).toEqual(
+          "'values' needs to be an array. Recieved string"
+        );
 
         expect(result).toEqual(undefined);
       });
     });
   });
 
-  describe('with valid values', () => {
-    it('concatinates strings with concatinator', () => {
-      const result = safeConcat(['a', 'b', 'c'], '-');
-      expect(result).toEqual('a-b-c');
+  describe("with valid values", () => {
+    it("concatinates strings with concatinator", () => {
+      const result = safeConcat(["a", "b", "c"], "-");
+      expect(result).toEqual("a-b-c");
     });
 
-    it('stringifies the concatinator', () => {
-      const result = safeConcat(['a', 'b', 'c'], 1);
-      expect(result).toEqual('a1b1c');
+    it("stringifies the concatinator", () => {
+      const result = safeConcat(["a", "b", "c"], 1);
+      expect(result).toEqual("a1b1c");
     });
 
-    it('removes falsey string values from values array', () => {
-      const result = safeConcat(['a', undefined, 'b', ''], '-');
-      expect(result).toEqual('a-b');
+    it("removes falsey string values from values array", () => {
+      const result = safeConcat(["a", undefined, "b", ""], "-");
+      expect(result).toEqual("a-b");
     });
 
-    it('does not append concatinator single values arrays', () => {
-      const result = safeConcat(['a'], '-');
-      expect(result).toEqual('a');
+    it("does not append concatinator single values arrays", () => {
+      const result = safeConcat(["a"], "-");
+      expect(result).toEqual("a");
     });
 
-    it('does not append concatinator to single truthy values', () => {
-      const result = safeConcat(['a', undefined], '-');
-      expect(result).toEqual('a');
+    it("does not append concatinator to single truthy values", () => {
+      const result = safeConcat(["a", undefined], "-");
+      expect(result).toEqual("a");
     });
   });
 
-  describe('with no valid values', () => {
-    it('returns empty string when no valid values', () => {
-      const result = safeConcat([undefined], '-');
-      expect(result).toEqual('');
+  describe("with no valid values", () => {
+    it("returns empty string when no valid values", () => {
+      const result = safeConcat([undefined], "-");
+      expect(result).toEqual("");
     });
   });
 });

package/src/deprecated/utility/__tests__/validateKeyType.spec.js

@@ -1,112 +1,128 @@
-//      
+//
 
-import validateKeyType from '../validateKeyType';
+import validateKeyType from "../validateKeyType";
 
-describe('validateKeyType', () => {
+describe("validateKeyType", () => {
   const objParam = {
     aArray: [1],
     aBoolean: true,
     aFunction: jest.fn(),
     aNumber: 1,
-    aObject: { foo: 'bar' },
-    aString: 'bar'
+    aObject: { foo: "bar" },
+    aString: "bar"
   };
 
-  describe('when obj param does not contain key param', () => {
-    it('returns false', () => {
-      const result = validateKeyType(objParam, 'wrong-key', 'string');
+  describe("when obj param does not contain key param", () => {
+    it("returns false", () => {
+      const result = validateKeyType(objParam, "wrong-key", "string");
       expect(result).toEqual(false);
     });
   });
 
-  describe('when obj param contains key param', () => {
-    describe('when obj[key] type', () => {
-      describe('matches type param', () => {
-        describe('of Array', () => {
-          it('returns true', () => {
-            const arrayResult = validateKeyType(objParam, 'aArray', 'array');
+  describe("when obj param contains key param", () => {
+    describe("when obj[key] type", () => {
+      describe("matches type param", () => {
+        describe("of Array", () => {
+          it("returns true", () => {
+            const arrayResult = validateKeyType(objParam, "aArray", "array");
             expect(arrayResult).toEqual(true);
           });
         });
 
-        describe('of Boolean', () => {
-          it('returns true', () => {
-            const arrayResult = validateKeyType(objParam, 'aBoolean', 'boolean');
+        describe("of Boolean", () => {
+          it("returns true", () => {
+            const arrayResult = validateKeyType(
+              objParam,
+              "aBoolean",
+              "boolean"
+            );
             expect(arrayResult).toEqual(true);
           });
         });
 
-        describe('of Function', () => {
-          it('returns true', () => {
-            const arrayResult = validateKeyType(objParam, 'aFunction', 'function');
+        describe("of Function", () => {
+          it("returns true", () => {
+            const arrayResult = validateKeyType(
+              objParam,
+              "aFunction",
+              "function"
+            );
             expect(arrayResult).toEqual(true);
           });
         });
 
-        describe('of Number', () => {
-          it('returns true', () => {
-            const arrayResult = validateKeyType(objParam, 'aNumber', 'number');
+        describe("of Number", () => {
+          it("returns true", () => {
+            const arrayResult = validateKeyType(objParam, "aNumber", "number");
             expect(arrayResult).toEqual(true);
           });
         });
 
-        describe('of Object', () => {
-          it('returns true', () => {
-            const arrayResult = validateKeyType(objParam, 'aObject', 'object');
+        describe("of Object", () => {
+          it("returns true", () => {
+            const arrayResult = validateKeyType(objParam, "aObject", "object");
             expect(arrayResult).toEqual(true);
           });
         });
 
-        describe('of String', () => {
-          it('returns true', () => {
-            const arrayResult = validateKeyType(objParam, 'aString', 'string');
+        describe("of String", () => {
+          it("returns true", () => {
+            const arrayResult = validateKeyType(objParam, "aString", "string");
             expect(arrayResult).toEqual(true);
           });
         });
       });
 
-      describe('does not match type param', () => {
-        describe('of Array', () => {
-          it('returns false', () => {
-            const arrayResult = validateKeyType(objParam, 'aArray', 'string');
+      describe("does not match type param", () => {
+        describe("of Array", () => {
+          it("returns false", () => {
+            const arrayResult = validateKeyType(objParam, "aArray", "string");
             expect(arrayResult).toEqual(false);
 
-            const arrayObjResult = validateKeyType(objParam, 'aArray', 'object');
+            const arrayObjResult = validateKeyType(
+              objParam,
+              "aArray",
+              "object"
+            );
             expect(arrayObjResult).toEqual(false);
           });
         });
 
-        describe('of Boolean', () => {
-          it('returns false', () => {
-            const arrayResult = validateKeyType(objParam, 'aBoolean', 'string');
+        describe("of Boolean", () => {
+          it("returns false", () => {
+            const arrayResult = validateKeyType(objParam, "aBoolean", "string");
             expect(arrayResult).toEqual(false);
           });
         });
 
-        describe('of Function', () => {
-          it('returns false', () => {
-            const arrayResult = validateKeyType(objParam, 'aFunction', 'string');
+        describe("of Function", () => {
+          it("returns false", () => {
+            const arrayResult = validateKeyType(
+              objParam,
+              "aFunction",
+              "string"
+            );
             expect(arrayResult).toEqual(false);
           });
         });
 
-        describe('of Number', () => {
-          it('returns false', () => {
-            const arrayResult = validateKeyType(objParam, 'aNumber', 'string');
+        describe("of Number", () => {
+          it("returns false", () => {
+            const arrayResult = validateKeyType(objParam, "aNumber", "string");
             expect(arrayResult).toEqual(false);
           });
         });
 
-        describe('of Object', () => {
-          it('returns false', () => {
-            const arrayResult = validateKeyType(objParam, 'aObject', 'string');
+        describe("of Object", () => {
+          it("returns false", () => {
+            const arrayResult = validateKeyType(objParam, "aObject", "string");
             expect(arrayResult).toEqual(false);
           });
         });
 
-        describe('of String', () => {
-          it('returns false', () => {
-            const arrayResult = validateKeyType(objParam, 'aString', 'number');
+        describe("of String", () => {
+          it("returns false", () => {
+            const arrayResult = validateKeyType(objParam, "aString", "number");
             expect(arrayResult).toEqual(false);
           });
         });

package/src/deprecated/utility/index.js

@@ -1,2 +1,2 @@
-export { default as safeConcat } from './safeConcat';
-export { default as validateKeyType } from './validateKeyType';
+export { default as safeConcat } from "./safeConcat";
+export { default as validateKeyType } from "./validateKeyType";

package/src/deprecated/utility/safeConcat.js

@@ -1,10 +1,10 @@
-//      
+//
 
-export default function safeConcat(values               , concatinator        ) {
+export default function safeConcat(values, concatinator) {
   if (!Array.isArray(values)) {
     console.error(`'values' needs to be an array. Recieved ${typeof values}`);
     return;
   }
 
-  return values.filter((val        ) => !!val).join(String(concatinator));
+  return values.filter(val => !!val).join(String(concatinator));
 }

package/src/deprecated/utility/validateKeyType.js

@@ -1,17 +1,15 @@
-//      
+//
 
-export default function validateKeyType(obj                         ,
-  expectedKey        ,
-  expectedType        )          {
+export default function validateKeyType(obj, expectedKey, expectedType) {
   if (!(expectedKey in obj)) {
     return false;
   }
 
-  if (expectedType === 'object' && Array.isArray(obj[expectedKey])) {
+  if (expectedType === "object" && Array.isArray(obj[expectedKey])) {
     return false;
   }
 
-  if (expectedType === 'array' && Array.isArray(obj[expectedKey])) {
+  if (expectedType === "array" && Array.isArray(obj[expectedKey])) {
     return true;
   }