@thecb/components 5.0.0-beta.15 → 5.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thecb/components",
-  "version": "5.0.0-beta.15",
+  "version": "5.0.0-beta.2",
   "description": "Common lib for CityBase react components",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
@@ -18,14 +18,9 @@
   "bugs": {
     "url": "https://github.com/CityBaseInc/cb-components/issues"
   },
-  "files": [
-    "dist",
-    "src"
-  ],
   "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",
@@ -39,6 +34,7 @@
     "@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",
@@ -77,14 +73,13 @@
     }
   },
   "dependencies": {
-    "@babel/runtime": "^7.15.4",
-    "formatted-input": "^1.0.0",
+    "formatted-input": "^0.1.3",
     "framer-motion": "^1.11.0",
     "numeral": "^2.0.6",
     "polished": "^4.0.3",
     "ramda": "^0.27.0",
     "react-aria-modal": "^4.0.0",
     "react-pose": "^4.0.10",
-    "redux-freeform": "^5.1.0-beta.7"
+    "redux-freeform": "^5.1.0-beta.2"
   }
 }

package/rollup.config.js

@@ -0,0 +1,53 @@
+import resolve from "rollup-plugin-node-resolve";
+import commonjs from "rollup-plugin-commonjs";
+import babel from "rollup-plugin-babel";
+import json from "rollup-plugin-json";
+import visualizer from "rollup-plugin-visualizer";
+import pkg from "./package.json";
+
+import * as formattedInput from "formatted-input";
+
+const globals = {
+  react: "React",
+  "react-dom": "ReactDOM"
+};
+
+const plugins = [
+  resolve({ preferBuiltins: false }),
+  babel({
+    exclude: "node_modules/**",
+    presets: ["@babel/env", "@babel/preset-react"]
+  }),
+  json(),
+  commonjs({
+    include: "node_modules/**",
+    namedExports: {
+      "formatted-input": Object.keys(formattedInput)
+    }
+  }),
+  visualizer()
+];
+
+const external = [...Object.keys(pkg.peerDependencies || {})];
+
+const output_data = [
+  {
+    file: pkg.main,
+    format: "cjs"
+  },
+  {
+    file: pkg.module,
+    format: "esm"
+  }
+];
+
+export default output_data.map(({ file, format }) => ({
+  input: "src/index.js",
+  output: {
+    file,
+    format,
+    globals
+  },
+  plugins,
+  external
+}));

package/src/components/molecules/modal/Modal.js

@@ -15,7 +15,7 @@ Styling accomplished with our atoms / layout primitives
 
 Cancel button will (for now) always use hideModal as its action
 Continue button takes an action, if you want to navigate to
-a different route (as with a link) connect() and use "push" from @thecb/connected-react-router
+a different route (as with a link) connect() and use "push" from connected-react-router
 */
 
 const getApplicationNode = () => document.getElementById("root");

package/src/components/molecules/payment-form-card/PaymentFormCard.state.js

@@ -26,7 +26,7 @@ const formConfig = {
     validators: [
       required(),
       hasLength(4, 4),
-      dateAfterToday("MMYY", "month", true)
+      dateAfterToday("MM/YY", "month", true)
     ],
     constraints: [onlyIntegers(), hasLength(0, 4)]
   },

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

@@ -1,61 +1,59 @@
-//
+//      
 
-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,128 +1,112 @@
-//
+//      
 
-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,15 +1,17 @@
-//
+//      
 
-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;
   }