@prismatic-io/spectral 7.0.12-pre → 7.0.13-pre

package/dist/testing.d.ts

@@ -59,6 +59,8 @@ export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);
+    private buildContext;
+    private buildParams;
     connectionValue({ key }: ConnectionDefinition): ConnectionValue;
     trigger(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<TriggerResult>;
     action(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<ActionPerformReturn>;

package/dist/testing.js

@@ -144,6 +144,13 @@ class ComponentTestHarness {
     constructor(component) {
         this.component = component;
     }
+    buildContext(context) {
+        return Object.assign(Object.assign({}, baseContext), context);
+    }
+    buildParams(inputs, params) {
+        const defaults = inputs.reduce((result, { key, default: defaultValue }) => (Object.assign(Object.assign({}, result), { [key]: `${defaultValue !== null && defaultValue !== void 0 ? defaultValue : ""}` })), {});
+        return Object.assign(Object.assign({}, defaults), params);
+    }
     connectionValue({ key }) {
         const { PRISMATIC_CONNECTION_VALUE: value } = process.env;
         if (!value) {
@@ -154,22 +161,20 @@ class ComponentTestHarness {
     }
     trigger(key, payload, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const realizedContext = Object.assign(Object.assign({}, baseContext), context);
             const trigger = this.component.triggers[key];
-            return trigger.perform(realizedContext, Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), Object.assign({}, params));
+            return trigger.perform(this.buildContext(context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
         });
     }
     action(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
-            const realizedContext = Object.assign(Object.assign({}, baseContext), context);
             const action = this.component.actions[key];
-            return action.perform(realizedContext, Object.assign({}, params));
+            return action.perform(this.buildContext(context), this.buildParams(action.inputs, params));
         });
     }
     dataSource(key, params) {
         return __awaiter(this, void 0, void 0, function* () {
             const dataSource = this.component.dataSources[key];
-            return dataSource.perform(Object.assign({}, params));
+            return dataSource.perform(this.buildParams(dataSource.inputs, params));
         });
     }
 }

package/dist/types/Inputs.d.ts

@@ -16,7 +16,7 @@ export declare type ObjectFieldMap = {
         defaultObject?: Element;
         defaultField?: Element;
     }[];
-    options: {
+    options?: {
         object: Element;
         fields: Element[];
     }[];

package/dist/util.js

@@ -25,25 +25,11 @@ const isObjectWithTruthyKeys = (value, keys) => {
  * @returns This function returns true if the type of `value` is an ObjectSelection, or false otherwise.
  */
 const isObjectSelection = (value) => {
-    if (Array.isArray(value)) {
-        for (const selection of value) {
-            if (isObjectWithTruthyKeys(selection, ["key"])) {
-                const { fields } = selection;
-                if (Array.isArray(fields) &&
-                    fields.length > 0 &&
-                    !fields.every((field) => isObjectWithTruthyKeys(field, ["key"]))) {
-                    return false;
-                }
-            }
-            else {
-                return false;
-            }
-        }
-    }
-    else {
-        return false;
+    if (typeof value === "string" && isJSON(value)) {
+        return isObjectSelection(JSON.parse(value));
     }
-    return true;
+    return (Array.isArray(value) &&
+        value.every((item) => isObjectWithTruthyKeys(item, ["object"])));
 };
 /**
  * This function coerces a provided value into an ObjectSelection if possible.
@@ -51,33 +37,31 @@ const isObjectSelection = (value) => {
  * @returns This function returns the the value as an ObjectSelection if possible.
  */
 const toObjectSelection = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toObjectSelection(JSON.parse(value));
+    }
     if (isObjectSelection(value)) {
         return value;
     }
-    throw new Error(`Value '${value}' cannot be coerced to ObjectSelection.`);
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to ObjectSelection.`);
 };
 /**
  * @param value The value to test
  * @returns This function returns true if the type of `value` is an ObjectFieldMap, or false otherwise.
  */
 const isObjectFieldMap = (value) => {
-    if (Array.isArray(value)) {
-        for (const fieldMap of value) {
-            if (isObjectWithTruthyKeys(fieldMap, ["key", "value"])) {
-                const { value: val } = fieldMap;
-                if (!isObjectWithTruthyKeys(val, ["objectKey", "fieldKey"])) {
-                    return false;
-                }
-            }
-            else {
-                return false;
-            }
-        }
+    if (typeof value === "string" && isJSON(value)) {
+        return isObjectFieldMap(JSON.parse(value));
     }
-    else {
-        return false;
+    if (Boolean(value) && typeof value === "object") {
+        const { fields } = value;
+        return (Array.isArray(fields) &&
+            fields.every((item) => isObjectWithTruthyKeys(item, ["field"]) &&
+                isObjectWithTruthyKeys(item === null || item === void 0 ? void 0 : item.field, [
+                    "key",
+                ])));
     }
-    return true;
+    return false;
 };
 /**
  * This function coerces a provided value into an ObjectFieldMap if possible.
@@ -85,16 +69,22 @@ const isObjectFieldMap = (value) => {
  * @returns This function returns the the value as an ObjectFieldMap if possible.
  */
 const toObjectFieldMap = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toObjectFieldMap(JSON.parse(value));
+    }
     if (isObjectFieldMap(value)) {
         return value;
     }
-    throw new Error(`Value '${value}' cannot be coerced to ObjectFieldMap.`);
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to ObjectFieldMap.`);
 };
 /**
  * @param value The value to test
  * @returns This function returns true if the type of `value` is a JSONForm, or false otherwise.
  */
 const isJSONForm = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return isJSONForm(JSON.parse(value));
+    }
     return isObjectWithTruthyKeys(value, ["schema", "uiSchema", "data"]);
 };
 /**
@@ -103,10 +93,13 @@ const isJSONForm = (value) => {
  * @returns This function returns the the value as a JSONForm if possible.
  */
 const toJSONForm = (value) => {
+    if (typeof value === "string" && isJSON(value)) {
+        return toJSONForm(JSON.parse(value));
+    }
     if (isJSONForm(value)) {
         return value;
     }
-    throw new Error(`Value '${value}' cannot be coerced to JSONForm.`);
+    throw new Error(`Value '${typeof value === "string" ? value : JSON.stringify(value)}' cannot be coerced to JSONForm.`);
 };
 /**
  * Determine if a variable is a boolean (true or false).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "7.0.12-pre",
+  "version": "7.0.13-pre",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"