separate out validation for the value of an imported prop vs the value of the whole import

Author: dhharker

__tests__/index.spec.js

@@ -53,8 +53,8 @@ describe('js-to-styles-vars-loader', () => {
         });
     });
 
-    describe('validateExportType', () => {
-      it ("throws on anything except an object, does not throw otherwise", () => {
+    describe('validation', () => {
+      it ("validateExportType() throws on anything except an object, does not throw otherwise", () => {
         const areOk = [{}, {a: "foo"}];
         const areNotOk = [[], ["a"], "", "123", 123, false, true, null, undefined, NaN];
         expect(() => {
@@ -69,7 +69,42 @@ describe('js-to-styles-vars-loader', () => {
             },).toThrow();
 
         }
+      })
+
+      it ("validateVariablesValue() throws on nested objects or invalid object property values", () => {
+        const areOk = [
+            {a: "foo"},
+            {a: 100.1},
+            {a: 100},
+            {a: ""},
+            {a: 0},
+            {a: 0},
+            {},
+        ];
+        const areNotOk = [
+            {a: 1/"bad"},
+            {b: []},
+            {c: ["bad"]},
+            {d: [100.1]},
+            {e: () => "bad"},
+            {f: {}},
+            {g: { b: "bad"} },
+            {h: "foo", b: {}},
+            {i: "foo", b: { c: "bad" }},
+            {j: "foo", b: { c: 100}}
+        ];
+        expect(() => {
+            for (const okThing of areOk) {
+                operator.validateVariablesValue(okThing, "");
+            }
+        }).not.toThrow();
+        for (const notOkThing of areNotOk) {
+            expect(() => {
+                operator.validateVariablesValue(notOkThing, "", "");
+                console.error(`Should have thrown on ${typeof notOkThing} '${JSON.stringify(notOkThing)}'`);
+            },).toThrow();
 
+        }
       })
     });
 
@@ -159,18 +194,13 @@ describe('js-to-styles-vars-loader', () => {
             addDependency () {}
         };
         const content = "require('./mocks/colors.js');\n" +
-            ".someClass { color: #fff;}";
-
-        const trimmer = (str) => {
-          return (str.split("\n").filter(a => a).map(s => s.trim()).join(" ")).trim()
-        };
+            ".someClass { color: #fff; }";
 
         it('inserts vars to styles content', () => {
             operator.mergeVarsToContent(content, context, 'less')
 
-            expect(trimmer(operator.mergeVarsToContent(content, context, 'less'))).toEqual(trimmer(`
-              @white: #fff; @black: #000; .someClass { color: #fff;}
-            `));
+            expect(operator.mergeVarsToContent(content, context, 'less'))
+                .toEqual("@white: #fff;\n@black: #000;\n\n.someClass { color: #fff; }");
         });
 
         it('call context.addDependecy', () => {

index.js

@@ -7,21 +7,44 @@ const requireReg = /require\s*\((["'])([\w.\/]+)(?:\1)\)((?:\.[\w_-]+)*);?/igm;
 const operator = {
 
     validateExportType (data, relativePath) {
-        if (data === null || typeof data !== "object" || Array.isArray(data)) {
-            throw new Error(`Value must be a flat object '${relativePath}'`)
+        if (Object.prototype.toString.call(data) !== '[object Object]') {
+            throw new Error(`Export must be an object '${relativePath}'`);
         }
     },
 
+    // Ensure it is a flat object with finite number/string values.
+    validateVariablesValue(value, property, relativePath) {
+        if (Object.prototype.toString.call(value) !== '[object Object]') {
+            throw new Error(`Only an object can be converted to style vars (${relativePath}${property})`);
+        }
+
+        const keys = Object.keys(value);
+        for (const k of keys) {
+            if (!(
+                // Define ok types of value (can be output as a style var)
+                typeof value[k] === "string"
+                || (typeof value[k] === "number" && Number.isFinite(value[k]))
+            )) {
+                throw new Error(
+                    `Style vars must have a value of type "string" or "number". Only flat objects are supported. ` +
+                    `In: ${relativePath}${property ? ":" : ""}${property}`);
+            }
+        }
+
+        return true;
+    },
+
     getVarData (relativePath, property) {
         decache(relativePath);
         const data = require(relativePath);
         if (!data) {
-            throw new Error(`No data in '${relativePath}'`)
+            throw new Error(`No data in '${relativePath}'`);
         }
         this.validateExportType(data, relativePath);
         if (property) {
             const propVal = squba(data, property);
             this.validateExportType(propVal, relativePath);
+            this.validateVariablesValue(propVal, property, relativePath)
             return propVal;
         }
         return data;