@kineticdata/react 5.0.15 → 5.0.18

package/lib/components/table/Table.redux.js

@@ -2,11 +2,14 @@ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 var _marked = /*#__PURE__*/_regeneratorRuntime.mark(calculateRowsTask),
-    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(configureTableTask);
+    _marked2 = /*#__PURE__*/_regeneratorRuntime.mark(configureTableTask),
+    _marked3 = /*#__PURE__*/_regeneratorRuntime.mark(pollingTask),
+    _marked4 = /*#__PURE__*/_regeneratorRuntime.mark(startPollingTask),
+    _marked5 = /*#__PURE__*/_regeneratorRuntime.mark(stopPollingTask);
 
 import { List, Map, fromJS } from 'immutable';
 import isarray from 'isarray';
-import { call, put, select, takeEvery } from 'redux-saga/effects';
+import { call, cancel, delay, fork, put, select, takeEvery } from 'redux-saga/effects';
 import { action, dispatch, regHandlers, regSaga } from '../../store';
 import { mountForm, unmountForm } from '..';
 export var hasData = function hasData(data) {
@@ -28,6 +31,18 @@ export var isClientSide = function isClientSide(tableData) {
   var dataSource = getDataSource(tableData);
   return hasData(data) && (dataSource && (dataSource.clientSideSearch === true || dataSource.clientSide) || !dataSource);
 };
+export var clientSideGotoPage = function clientSideGotoPage(tableData, pageNumber) {
+  var data = tableData.get('data');
+  var pageSize = tableData.get('pageSize');
+  var newOffset = (pageNumber - 1) * pageSize;
+
+  if (typeof pageNumber !== 'number' || pageNumber < 1) {
+    return tableData;
+  }
+
+  if (newOffset > data.size) return tableData;
+  return tableData.set('pageOffset', newOffset);
+};
 
 var clientSideNextPage = function clientSideNextPage(tableData) {
   return tableData.update('pageOffset', function (pageOffset) {
@@ -41,6 +56,21 @@ var clientSidePrevPage = function clientSidePrevPage(tableData) {
   });
 };
 
+export var serverSideGotoPage = function serverSideGotoPage(tableData, pageNumber) {
+  var pageTokens = tableData.get('pageTokens');
+  var tokenLocation = pageNumber - 2;
+
+  if (typeof pageNumber !== 'number' || pageNumber < 1 || pageNumber > pageTokens.size) {
+    return tableData;
+  }
+
+  if (pageNumber === 1) {
+    return tableData.set('loading', true).set('nextPageToken', null).set('pageTokens', List());
+  }
+
+  return tableData.set('loading', true).set('nextPageToken', pageTokens.get(tokenLocation)).set('pageTokens', pageTokens.slice(0, tokenLocation));
+};
+
 var serverSideNextPage = function serverSideNextPage(tableData) {
   return tableData.set('loading', true).set('nextPageToken', tableData.get('currentPageToken')).update('pageTokens', function (pt) {
     return pt.push(tableData.get('currentPageToken'));
@@ -104,7 +134,8 @@ regHandlers({
         defaultSortDirection = _ref3$payload$default2 === void 0 ? 'desc' : _ref3$payload$default2,
         tableOptions = _ref3$payload.tableOptions,
         onValidateFilters = _ref3$payload.onValidateFilters,
-        filterForm = _ref3$payload.filterForm;
+        filterForm = _ref3$payload.filterForm,
+        onFetch = _ref3$payload.onFetch;
     return !state.getIn(['tables', tableKey, 'mounted']) ? state : state.hasIn(['tables', tableKey, 'configured']) ? state.setIn(['tables', tableKey, 'initialize'], false) : state.mergeIn(['tables', tableKey], Map({
       data: hasData(data) ? fromJS(data) : data,
       dataSource: dataSource,
@@ -121,6 +152,7 @@ regHandlers({
       nextPageToken: null,
       pageTokens: List(),
       pageOffset: 0,
+      count: null,
       error: null,
       // Filtering
       filterForm: filterForm,
@@ -128,6 +160,7 @@ regHandlers({
       appliedFilters: generateFilters(tableKey, columns),
       validFilters: true,
       onValidateFilters: onValidateFilters,
+      onFetch: onFetch,
       configured: true,
       initialize: true
     }));
@@ -138,10 +171,11 @@ regHandlers({
         rows = _ref4$payload.rows,
         data = _ref4$payload.data,
         nextPageToken = _ref4$payload.nextPageToken,
+        count = _ref4$payload.count,
         _ref4$payload$error = _ref4$payload.error,
         error = _ref4$payload$error === void 0 ? null : _ref4$payload$error;
     return state.updateIn(['tables', tableKey], function (table) {
-      return table && table.set('rows', rows).set('data', data).set('currentPageToken', nextPageToken).set('nextPageToken', null).set('error', error).set('initializing', false).set('loading', false);
+      return table && table.set('rows', rows).set('data', data).set('currentPageToken', nextPageToken).set('nextPageToken', null).set('count', count).set('error', error).set('initializing', false).set('loading', false);
     });
   },
   NEXT_PAGE: function NEXT_PAGE(state, _ref5) {
@@ -156,10 +190,18 @@ regHandlers({
       return isClientSide(tableData) ? clientSidePrevPage(tableData) : serverSidePrevPage(tableData);
     }).setIn(['tables', tableKey, 'error'], null);
   },
-  SORT_COLUMN: function SORT_COLUMN(state, _ref7) {
+  GOTO_PAGE: function GOTO_PAGE(state, _ref7) {
     var _ref7$payload = _ref7.payload,
         tableKey = _ref7$payload.tableKey,
-        column = _ref7$payload.column;
+        pageNumber = _ref7$payload.pageNumber;
+    return state.updateIn(['tables', tableKey], function (tableData) {
+      return isClientSide(tableData) ? clientSideGotoPage(tableData, pageNumber) : serverSideGotoPage(tableData, pageNumber);
+    }).setIn(['tables', tableKey, 'error'], null);
+  },
+  SORT_COLUMN: function SORT_COLUMN(state, _ref8) {
+    var _ref8$payload = _ref8.payload,
+        tableKey = _ref8$payload.tableKey,
+        column = _ref8$payload.column;
     return state.updateIn(['tables', tableKey], function (t) {
       var sortColumn = t.get('sortColumn');
       var sortDirection = t.get('sortDirection');
@@ -168,52 +210,52 @@ regHandlers({
       .set('sortDirection', sortColumn === column ? sortDirection === 'desc' ? 'asc' : 'desc' : 'asc').set('sortColumn', column).set('error', null);
     });
   },
-  SET_FILTER: function SET_FILTER(state, _ref8) {
-    var _ref8$payload = _ref8.payload,
-        tableKey = _ref8$payload.tableKey,
-        filter = _ref8$payload.filter,
-        value = _ref8$payload.value;
+  SET_FILTER: function SET_FILTER(state, _ref9) {
+    var _ref9$payload = _ref9.payload,
+        tableKey = _ref9$payload.tableKey,
+        filter = _ref9$payload.filter,
+        value = _ref9$payload.value;
     return state.updateIn(['tables', tableKey], function (table) {
       return table.setIn(['filters', filter, 'value'], value).set('validFilters', evaluateValidFilters(table));
     });
   },
-  APPLY_FILTERS: function APPLY_FILTERS(state, _ref9) {
-    var tableKey = _ref9.payload.tableKey;
+  APPLY_FILTERS: function APPLY_FILTERS(state, _ref10) {
+    var tableKey = _ref10.payload.tableKey;
     return state.updateIn(['tables', tableKey], function (table) {
       return table.set('loading', true).set('appliedFilters', state.getIn(['tables', tableKey, 'filters'])).set('pageOffset', 0).set('currentPageToken', null).set('nextPageToken', null).set('pageTokens', List()).set('error', null);
     });
   },
-  APPLY_FILTER_FORM: function APPLY_FILTER_FORM(state, _ref10) {
-    var _ref10$payload = _ref10.payload,
-        tableKey = _ref10$payload.tableKey,
-        appliedFilters = _ref10$payload.appliedFilters;
+  APPLY_FILTER_FORM: function APPLY_FILTER_FORM(state, _ref11) {
+    var _ref11$payload = _ref11.payload,
+        tableKey = _ref11$payload.tableKey,
+        appliedFilters = _ref11$payload.appliedFilters;
     return state.updateIn(['tables', tableKey], function (table) {
       return table.set('loading', true).set('appliedFilters', appliedFilters).set('pageOffset', 0).set('currentPageToken', null).set('nextPageToken', null).set('pageTokens', List()).set('error', null);
     });
   },
-  REFETCH_TABLE_DATA: function REFETCH_TABLE_DATA(state, _ref11) {
-    var tableKey = _ref11.payload.tableKey;
+  REFETCH_TABLE_DATA: function REFETCH_TABLE_DATA(state, _ref12) {
+    var tableKey = _ref12.payload.tableKey;
     return state.hasIn(['tables', tableKey]) ? state.updateIn(['tables', tableKey], function (tableData) {
       return tableData.get('dataSource') ? tableData.set('loading', true).set('pageOffset', 0).set('currentPageToken', null).set('nextPageToken', null).set('pageTokens', List()).set('data', null).set('error', null) : tableData;
     }) : state;
   },
-  CLEAR_TABLE_FILTERS: function CLEAR_TABLE_FILTERS(state, _ref12) {
-    var tableKey = _ref12.payload.tableKey;
+  CLEAR_TABLE_FILTERS: function CLEAR_TABLE_FILTERS(state, _ref13) {
+    var tableKey = _ref13.payload.tableKey;
     return state.setIn(['tables', tableKey, 'filters'], generateFilters(tableKey, state.getIn(['tables', tableKey, 'columns'])));
   },
-  CLEAR_SELECTED_FILTERS: function CLEAR_SELECTED_FILTERS(state, _ref13) {
-    var tableKey = _ref13.payload.tableKey;
+  CLEAR_SELECTED_FILTERS: function CLEAR_SELECTED_FILTERS(state, _ref14) {
+    var tableKey = _ref14.payload.tableKey;
     return state.setIn(['tables', tableKey, 'filters'], state.getIn(['tables', tableKey, 'appliedFilters']));
   }
 });
 
-function calculateRowsTask(_ref14) {
-  var payload, tableKey, tableData, response, rows, data, nextPageToken, error;
+function calculateRowsTask(_ref15) {
+  var payload, tableKey, tableData, response, rows, data, nextPageToken, error, onFetch;
   return _regeneratorRuntime.wrap(function calculateRowsTask$(_context) {
     while (1) {
       switch (_context.prev = _context.next) {
         case 0:
-          payload = _ref14.payload;
+          payload = _ref15.payload;
           _context.prev = 1;
           tableKey = payload.tableKey;
           _context.next = 5;
@@ -238,13 +280,14 @@ function calculateRowsTask(_ref14) {
         case 10:
           response = _context.sent;
           rows = response.rows, data = response.data, nextPageToken = response.nextPageToken, error = response.error;
+          onFetch = tableData.get('onFetch');
 
           if (!error) {
-            _context.next = 17;
+            _context.next = 18;
             break;
           }
 
-          _context.next = 15;
+          _context.next = 16;
           return put({
             type: 'SET_ROWS',
             payload: {
@@ -256,12 +299,12 @@ function calculateRowsTask(_ref14) {
             }
           });
 
-        case 15:
-          _context.next = 19;
+        case 16:
+          _context.next = 20;
           break;
 
-        case 17:
-          _context.next = 19;
+        case 18:
+          _context.next = 20;
           return put({
             type: 'SET_ROWS',
             payload: {
@@ -272,30 +315,43 @@ function calculateRowsTask(_ref14) {
             }
           });
 
-        case 19:
-          _context.next = 24;
+        case 20:
+          if (!(typeof onFetch === 'function')) {
+            _context.next = 23;
+            break;
+          }
+
+          _context.next = 23;
+          return call(onFetch, {
+            tableKey: tableKey,
+            rows: rows,
+            error: error
+          });
+
+        case 23:
+          _context.next = 28;
           break;
 
-        case 21:
-          _context.prev = 21;
+        case 25:
+          _context.prev = 25;
           _context.t0 = _context["catch"](1);
           console.error(_context.t0);
 
-        case 24:
+        case 28:
         case "end":
           return _context.stop();
       }
     }
-  }, _marked, null, [[1, 21]]);
+  }, _marked, null, [[1, 25]]);
 }
 
-function configureTableTask(_ref15) {
+function configureTableTask(_ref16) {
   var payload, filterForm, tableKey, initialFilterValues;
   return _regeneratorRuntime.wrap(function configureTableTask$(_context2) {
     while (1) {
       switch (_context2.prev = _context2.next) {
         case 0:
-          payload = _ref15.payload;
+          payload = _ref16.payload;
           filterForm = payload.filterForm, tableKey = payload.tableKey, initialFilterValues = payload.initialFilterValues;
 
           if (filterForm) {
@@ -327,9 +383,114 @@ function configureTableTask(_ref15) {
   }, _marked2);
 }
 
-regSaga(takeEvery('CONFIGURE_TABLE', configureTableTask));
+var pollerTableKeys = {};
+
+function pollingTask(tableKey) {
+  return _regeneratorRuntime.wrap(function pollingTask$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          if (!true) {
+            _context3.next = 6;
+            break;
+          }
+
+          _context3.next = 3;
+          return delay(10000);
+
+        case 3:
+          refetchTable(tableKey);
+          _context3.next = 0;
+          break;
+
+        case 6:
+        case "end":
+          return _context3.stop();
+      }
+    }
+  }, _marked3);
+}
+
+function startPollingTask(_ref17) {
+  var payload, refreshInterval, tableKey;
+  return _regeneratorRuntime.wrap(function startPollingTask$(_context4) {
+    while (1) {
+      switch (_context4.prev = _context4.next) {
+        case 0:
+          payload = _ref17.payload;
+          refreshInterval = payload.refreshInterval, tableKey = payload.tableKey;
+
+          if (!(refreshInterval && !pollerTableKeys[tableKey])) {
+            _context4.next = 6;
+            break;
+          }
+
+          _context4.next = 5;
+          return fork(pollingTask, tableKey, refreshInterval);
+
+        case 5:
+          pollerTableKeys[tableKey] = _context4.sent;
+
+        case 6:
+        case "end":
+          return _context4.stop();
+      }
+    }
+  }, _marked4);
+}
+
+function stopPollingTask(_ref18) {
+  var payload, tableKey;
+  return _regeneratorRuntime.wrap(function stopPollingTask$(_context5) {
+    while (1) {
+      switch (_context5.prev = _context5.next) {
+        case 0:
+          payload = _ref18.payload;
+          tableKey = payload.tableKey;
+
+          if (!pollerTableKeys[tableKey]) {
+            _context5.next = 6;
+            break;
+          }
+
+          _context5.next = 5;
+          return cancel(pollerTableKeys[tableKey]);
+
+        case 5:
+          pollerTableKeys[tableKey] = null;
+
+        case 6:
+        case "end":
+          return _context5.stop();
+      }
+    }
+  }, _marked5);
+}
+
+regSaga('CONFIGURE_TABLE', /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+  return _regeneratorRuntime.wrap(function _callee$(_context6) {
+    while (1) {
+      switch (_context6.prev = _context6.next) {
+        case 0:
+          _context6.next = 2;
+          return takeEvery('CONFIGURE_TABLE', configureTableTask);
+
+        case 2:
+          _context6.next = 4;
+          return takeEvery('CONFIGURE_TABLE', startPollingTask);
+
+        case 4:
+        case "end":
+          return _context6.stop();
+      }
+    }
+  }, _callee);
+})); //
+
+regSaga(takeEvery('UNMOUNT_TABLE', stopPollingTask));
 regSaga(takeEvery('NEXT_PAGE', calculateRowsTask));
 regSaga(takeEvery('PREV_PAGE', calculateRowsTask));
+regSaga(takeEvery('GOTO_PAGE', calculateRowsTask));
 regSaga(takeEvery('SORT_COLUMN', calculateRowsTask));
 regSaga(takeEvery('SORT_DIRECTION', calculateRowsTask));
 regSaga(takeEvery('APPLY_FILTERS', calculateRowsTask));
@@ -459,33 +620,40 @@ var calculateRows = function calculateRows(tableData) {
     var rows = applyClientSideFilters(tableData, data);
     return Promise.resolve({
       rows: rows,
-      data: data
+      data: data,
+      count: rows.size
     });
   } else if (dataSource) {
-    var transform = dataSource.transform || function (result) {
-      return result;
-    };
-
-    var params = dataSource.params({
+    var paramData = {
       pageSize: tableData.get('pageSize'),
       filters: tableData.get('appliedFilters'),
       sortColumn: tableData.getIn(['sortColumn', 'value']),
       sortDirection: tableData.get('sortDirection'),
-      nextPageToken: tableData.get('nextPageToken')
-    });
+      nextPageToken: tableData.get('nextPageToken'),
+      pageTokens: tableData.get('pageTokens')
+    };
+
+    var transform = dataSource.transform || function (result) {
+      return result;
+    };
+
+    var params = dataSource.params(paramData);
     return dataSource.fn.apply(dataSource, _toConsumableArray(params)).then(function (response) {
       if (response.error) return response;
 
-      var _transform = transform(response),
+      var _transform = transform(response, paramData),
           nextPageToken = _transform.nextPageToken,
-          responseData = _transform.data;
+          responseData = _transform.data,
+          count = _transform.count;
 
       var data = fromJS(responseData);
-      var rows = transformData(data, tableData);
+      var transformedRows = transformData(data, tableData);
+      var rows = dataSource.clientSideSearch || dataSource.clientSide ? applyClientSideFilters(tableData, transformedRows) : transformedRows;
       return {
         nextPageToken: nextPageToken,
+        count: dataSource.clientSideSearch || dataSource.clientSide ? rows.size : count,
         data: data,
-        rows: dataSource.clientSideSearch || dataSource.clientSide ? applyClientSideFilters(tableData, rows) : rows
+        rows: rows
       };
     });
   } else {

package/lib/components/table/Table.redux.test.js

@@ -1,5 +1,5 @@
-import { operations, isValueEmpty } from './Table.redux';
-import { List } from 'immutable';
+import { operations, isValueEmpty, clientSideGotoPage, serverSideGotoPage } from './Table.redux';
+import { List, Range, Map } from 'immutable';
 describe('<Table /> redux', function () {
   describe('setup', function () {
     test('true dat', function () {
@@ -86,4 +86,75 @@ describe('<Table /> redux', function () {
       expect(isValueEmpty(a)).toBeFalsy();
     });
   });
+  describe('#clientSideGotoPage', function () {
+    var tableData;
+    beforeEach(function () {
+      tableData = Map({
+        pageSize: 5,
+        pageOffset: 0,
+        data: Range(1, 25).toList()
+      });
+    });
+    describe('when pageNumber is invalid', function () {
+      test('invalid type does not affect tableData', function () {
+        expect(clientSideGotoPage(tableData, 'foo')).toEqualImmutable(tableData);
+      });
+      test('invalid number does not affect tableData', function () {
+        expect(clientSideGotoPage(tableData, -1)).toEqualImmutable(tableData);
+      });
+    });
+    test('pageNumber 1 offset is 0', function () {
+      var newTableData = clientSideGotoPage(tableData.set('pageOffset', 10), 1);
+      expect(newTableData.get('pageOffset')).toBe(0);
+    });
+    test('pageNumber 2 offset is 5', function () {
+      var newTableData = clientSideGotoPage(tableData, 2);
+      expect(newTableData.get('pageOffset')).toBe(5);
+    });
+    test('pageNumber 6 offset is unchanged (past the end of the data)', function () {
+      var newTableData = clientSideGotoPage(tableData, 6);
+      expect(newTableData.get('pageOffset')).toBe(0);
+    });
+    test('pageNumber 5 offset is 20 (last page)', function () {
+      var newTableData = clientSideGotoPage(tableData, 5);
+      expect(newTableData.get('pageOffset')).toBe(20);
+    });
+  });
+  describe('#serverSideGotoPage', function () {
+    var tableData;
+    beforeEach(function () {
+      tableData = Map({
+        loading: false,
+        nextPageToken: 'abc',
+        pageTokens: List([2, 3, 4])
+      });
+    });
+    describe('when pageNumber is invalid', function () {
+      test('invalid type does not affect tableData', function () {
+        expect(serverSideGotoPage(tableData, 'foo')).toEqualImmutable(tableData);
+      });
+      test('invalid number does not affect tableData', function () {
+        expect(serverSideGotoPage(tableData, -1)).toEqualImmutable(tableData);
+      });
+    });
+    test('when there are not enough pageTokens it does not affect tableData', function () {
+      expect(serverSideGotoPage(tableData, 5)).toEqualImmutable(tableData);
+    });
+    test('when going to the first page reset the page tokens', function () {
+      var newTableData = serverSideGotoPage(tableData, 1);
+      expect(newTableData.get('loading')).toBe(true);
+      expect(newTableData.get('nextPageToken')).toBeNull();
+      expect(newTableData.get('pageTokens').size).toBe(0);
+    });
+    test('when going to a valid page use its pageToken and adjust the page tokens', function () {
+      var secondTableData = serverSideGotoPage(tableData, 2);
+      var thirdTableData = serverSideGotoPage(tableData, 3);
+      expect(secondTableData.get('loading')).toBe(true);
+      expect(secondTableData.get('nextPageToken')).toBe(2);
+      expect(secondTableData.get('pageTokens').size).toBe(0);
+      expect(thirdTableData.get('loading')).toBe(true);
+      expect(thirdTableData.get('nextPageToken')).toBe(3);
+      expect(thirdTableData.get('pageTokens').size).toBe(1);
+    });
+  });
 });

package/lib/components/task/builder/Connector.js

@@ -73,8 +73,8 @@ export var Connector = /*#__PURE__*/function (_Component) {
         });
       } // when dropping a new connector the `headNode` prop will be undefined
       else if (_this.props.headNode) {
-          _this.setHead(_this.props.headNode.position, false);
-        }
+        _this.setHead(_this.props.headNode.position, false);
+      }
     };
 
     _this.dropTail = function () {

package/lib/components/task/builder/NodeForm.js

@@ -165,6 +165,9 @@ var fields = function fields(_ref3) {
             type: type,
             value: values.get("message_".concat(type))
           });
+        }) // Do not serialize empty messages.
+        .filter(function (message) {
+          return !!message.value;
         });
       }
     }]);

package/lib/components/task/builder/TaskDefinitionConfigForm.js

@@ -0,0 +1,113 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { List, Map } from 'immutable';
+import { generateForm } from '../../form/Form';
+import { fetchForm, fetchKapps } from '../../../apis';
+export var checkOmittedParameters = function checkOmittedParameters(node, parameter) {
+  if (node.definitionId === 'system_submission_create_v1') {
+    return !['kappSlug', 'formSlug'].includes(parameter.id);
+  } else {
+    return true;
+  }
+};
+export var generateTaskDefinition = function generateTaskDefinition(taskDefinition) {
+  if (taskDefinition.definitionName === 'system_submission_create') {
+    return function (_ref) {
+      var form = _ref.form;
+      return _objectSpread(_objectSpread({}, taskDefinition), {}, {
+        parameters: [].concat(_toConsumableArray(taskDefinition.parameters.map(function (parameter) {
+          return parameter.id === 'kappSlug' ? _objectSpread(_objectSpread({}, parameter), {}, {
+            defaultValue: form.kapp.slug
+          }) : parameter.id === 'formSlug' ? _objectSpread(_objectSpread({}, parameter), {}, {
+            defaultValue: form.slug
+          }) : parameter;
+        })), _toConsumableArray(form.fields.map(function (field) {
+          return {
+            name: field.name,
+            defaultValue: '',
+            dependsOnId: null,
+            dependsOnValue: null,
+            description: '',
+            id: "values.".concat(field.name),
+            required: false
+          };
+        })))
+      });
+    };
+  } else {
+    return null;
+  }
+};
+
+var dataSources = function dataSources() {
+  return {
+    kapps: {
+      fn: fetchKapps,
+      params: [],
+      transform: function transform(data) {
+        return data.kapps;
+      }
+    }
+  };
+};
+
+var fields = function fields() {
+  return function () {
+    return [{
+      name: 'kappSlug',
+      label: 'Kapp',
+      type: 'select',
+      required: true,
+      options: function options(_ref2) {
+        var kapps = _ref2.kapps;
+        return kapps ? kapps.map(function (kapp) {
+          return Map({
+            value: kapp.get('slug'),
+            label: kapp.get('name')
+          });
+        }) : List();
+      },
+      onChange: function onChange(_ref3, actions) {
+        var values = _ref3.values;
+
+        if (!!values.get('form')) {
+          actions.setValue('form', null);
+        }
+      }
+    }, {
+      name: 'form',
+      label: 'Form',
+      type: 'form',
+      required: true,
+      enabled: function enabled(_ref4) {
+        var values = _ref4.values;
+        return values.get('kappSlug') !== '';
+      },
+      search: function search(_ref5) {
+        var values = _ref5.values;
+        return values.get('kappSlug') !== '' ? {
+          kappSlug: values.get('kappSlug')
+        } : {};
+      }
+    }];
+  };
+};
+
+var handleSubmit = function handleSubmit(_ref6) {
+  var taskDefinition = _ref6.taskDefinition;
+  return function (values) {
+    return fetchForm({
+      kappSlug: values.get('kappSlug'),
+      formSlug: values.getIn(['form', 'slug'], ''),
+      include: 'fields,kapp'
+    }).then(generateTaskDefinition(taskDefinition));
+  };
+};
+
+export var TaskDefinitionConfigForm = generateForm({
+  formOptions: ['taskDefinition'],
+  dataSources: dataSources,
+  fields: fields,
+  handleSubmit: handleSubmit
+});
+TaskDefinitionConfigForm.displayName = 'TaskDefinitionConfigForm';

package/lib/components/task/builder/TreeBuilder.js

@@ -218,8 +218,8 @@ export var TreeBuilderComponent = /*#__PURE__*/function (_Component) {
         } // otherwise check for changes to the highlight prop and focus if it changes
         // and its a truthy value
         else if (this.props.highlight && !this.props.highlight.equals(prevProps.highlight)) {
-            this.panTo(this.props.highlight);
-          }
+          this.panTo(this.props.highlight);
+        }
       }
     }
   }, {