@kineticdata/react 5.1.2 → 6.0.0

package/lib/components/task/workflows/WorkflowTable.js

@@ -1,22 +1,27 @@
-import { generateTable } from '../../table/Table';
-import { fetchSources, fetchTrees } from '../../../apis';
-import { defineFilter } from '../../../helpers';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WorkflowTable = void 0;
+var _Table = require("../../table/Table");
+var _apis = require("../../../apis");
+var _helpers = require("../../../helpers");
 var STATUS_OPTIONS = ['Active', 'Inactive', 'Paused'].map(function (v) {
   return {
     label: v,
     value: v
   };
 });
-var clientSide = defineFilter(true).equals('name', 'name').startsWith('name', 'nameFragment').equals('sourceName', 'source').equals('sourceGroup', 'sourceGroup').startsWith('sourceGroup', 'sourceGroupFragment').startsWith('ownerEmail', 'ownerEmail').equals('status', 'status').end();
-
+var clientSide = (0, _helpers.defineFilter)(true).equals('name', 'name').startsWith('name', 'nameFragment').equals('sourceName', 'source').equals('sourceGroup', 'sourceGroup').startsWith('sourceGroup', 'sourceGroupFragment').startsWith('ownerEmail', 'ownerEmail').equals('status', 'status').end();
 var dataSource = function dataSource(_ref) {
   var alterData = _ref.alterData,
-      workflowType = _ref.workflowType,
-      sourceName = _ref.sourceName,
-      sourceGroup = _ref.sourceGroup;
+    workflowType = _ref.workflowType,
+    sourceName = _ref.sourceName,
+    sourceGroup = _ref.sourceGroup;
   return {
     clientSide: !!alterData ? clientSide : false,
-    fn: fetchTrees,
+    fn: _apis.fetchTrees,
     params: function params(paramData) {
       return [{
         name: paramData.filters.get('name'),
@@ -42,11 +47,10 @@ var dataSource = function dataSource(_ref) {
     }
   };
 };
-
 var filterDataSources = function filterDataSources() {
   return {
     sourceTypes: {
-      fn: fetchSources,
+      fn: _apis.fetchSources,
       params: [],
       transform: function transform(result) {
         return result.sources.filter(function (s) {
@@ -61,7 +65,6 @@ var filterDataSources = function filterDataSources() {
     }
   };
 };
-
 var filters = function filters() {
   return function (_ref2) {
     var sourceTypes = _ref2.sourceTypes;
@@ -98,7 +101,6 @@ var filters = function filters() {
     }];
   };
 };
-
 var columns = [{
   value: 'id',
   title: 'ID',
@@ -159,11 +161,12 @@ var columns = [{
   title: 'Updated By',
   sortable: false
 }];
-export var WorkflowTable = generateTable({
+var WorkflowTable = (0, _Table.generateTable)({
   tableOptions: ['alterData', 'workflowType', 'sourceName', 'sourceGroup'],
   columns: columns,
   filters: filters,
   filterDataSources: filterDataSources,
   dataSource: dataSource
 });
+exports.WorkflowTable = WorkflowTable;
 WorkflowTable.displayName = 'WorkflowTable';

package/lib/helpers/SearchBuilder.js

@@ -1,26 +1,29 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import { Seq } from 'immutable';
-import { isArray, isEmpty, isString, constant, every, last, map, some } from 'lodash-es';
-import { get, isImmutable } from 'immutable';
-
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defineKqlQuery = exports.defineFilter = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/toConsumableArray"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/objectSpread2"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/createClass"));
+var _immutable = require("immutable");
+var _lodashEs = require("lodash-es");
 var defineKqlQuery = function defineKqlQuery() {
   return new SearchBuilder('kql');
 };
-
+exports.defineKqlQuery = defineKqlQuery;
 var defineFilter = function defineFilter(caseInsensitive, rootOperator) {
   return new SearchBuilder('filter', caseInsensitive, rootOperator);
 };
-
+exports.defineFilter = defineFilter;
 var SearchBuilder = /*#__PURE__*/function () {
   function SearchBuilder(type) {
     var caseInsensitive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
     var rootOperator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'and';
-
-    _classCallCheck(this, SearchBuilder);
-
+    (0, _classCallCheck2["default"])(this, SearchBuilder);
     this.caseInsensitive = caseInsensitive;
     this.type = type;
     this.rootExpression = {
@@ -29,8 +32,7 @@ var SearchBuilder = /*#__PURE__*/function () {
     };
     this.expressionStack = [this.rootExpression];
   }
-
-  _createClass(SearchBuilder, [{
+  (0, _createClass2["default"])(SearchBuilder, [{
     key: "and",
     value: function and() {
       return pushExpression(this, {}, 'and');
@@ -103,7 +105,6 @@ var SearchBuilder = /*#__PURE__*/function () {
     key: "end",
     value: function end() {
       var _this = this;
-
       if (this.expressionStack.length === 1) {
         return this.type === 'kql' ? function (values) {
           return compileKqlQuery(_this.rootExpression, values).replace(/^\s*\(\s*/, '').replace(/\s*\)\s*$/, '');
@@ -114,7 +115,6 @@ var SearchBuilder = /*#__PURE__*/function () {
       }
     }
   }]);
-
   return SearchBuilder;
 }(); // This could be a method of SearchBuilder but we don't have a way to make it
 // private so its here...
@@ -122,39 +122,30 @@ var SearchBuilder = /*#__PURE__*/function () {
 // so we push the given expression to the end of that one. Then if the given
 // expression is another 'and' / 'or' operation we push the new expression
 // to the expression stack and subsequent expressions will be added to that one.
-
-
 var pushExpression = function pushExpression(self, options, operator) {
-  var currentExpression = last(self.expressionStack);
-
+  var currentExpression = (0, _lodashEs.last)(self.expressionStack);
   for (var _len = arguments.length, operands = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
     operands[_key - 3] = arguments[_key];
   }
-
   currentExpression.operands.push({
     operator: operator,
     operands: operands,
-    options: _objectSpread({
+    options: (0, _objectSpread2["default"])({
       caseInsensitive: self.caseInsensitive
     }, options)
   });
-
   if (['and', 'or'].includes(operator)) {
-    self.expressionStack.push(last(currentExpression.operands));
+    self.expressionStack.push((0, _lodashEs.last)(currentExpression.operands));
   }
-
   return self;
 };
-
 var nullFix = function nullFix(val) {
   return val === null || typeof val === 'undefined' ? '""' : "\"".concat(val, "\"");
 };
-
 var compileKqlQuery = function compileKqlQuery(_ref, values) {
   var operator = _ref.operator,
-      operands = _ref.operands,
-      options = _ref.options;
-
+    operands = _ref.operands,
+    options = _ref.options;
   switch (operator) {
     case 'or':
     case 'and':
@@ -165,16 +156,12 @@ var compileKqlQuery = function compileKqlQuery(_ref, values) {
       });
       var combinator = operator === 'and' ? 'AND' : 'OR';
       return andContents.length > 0 ? "( ".concat(andContents.join(" ".concat(combinator, " ")), " )") : '';
-
     case 'eq':
       return options.strict || values[operands[1]] ? "".concat(operands[0], " = ").concat(nullFix(values[operands[1]])) : '';
-
     case 'sw':
       return options.strict || values[operands[1]] ? "".concat(operands[0], " =* ").concat(nullFix(values[operands[1]])) : '';
-
     case 'mt':
       return values[operands[1]] ? "".concat(operands[0], " *=* ").concat(nullFix(values[operands[1]])) : '';
-
     case 'in':
       {
         var rval = values[operands[1]];
@@ -185,7 +172,6 @@ var compileKqlQuery = function compileKqlQuery(_ref, values) {
         }).join(', ') : '';
         return inList ? "".concat(operands[0], " IN (").concat(inList, ")") : '';
       }
-
     case 'bt':
       {
         var lval = operands[0];
@@ -193,182 +179,147 @@ var compileKqlQuery = function compileKqlQuery(_ref, values) {
         var rval2 = values[operands[2]];
         return options.strict || rval1 && rval2 ? "".concat(lval, " BETWEEN (").concat(nullFix(rval1), ", ").concat(nullFix(rval2), ")") : '';
       }
-
     case 'gt':
       return options.strict || values[operands[1]] ? "".concat(operands[0], " > ").concat(nullFix(values[operands[1]])) : '';
-
     case 'gte':
       return options.strict || values[operands[1]] ? "".concat(operands[0], " >= ").concat(nullFix(values[operands[1]])) : '';
-
     case 'lt':
       return options.strict || values[operands[1]] ? "".concat(operands[0], " < ").concat(nullFix(values[operands[1]])) : '';
-
     case 'lte':
       return options.strict || values[operands[1]] ? "".concat(operands[0], " <= ").concat(nullFix(values[operands[1]])) : '';
-
     default:
       return '';
   }
 };
-
 var compileExpression = function compileExpression(_ref2) {
   var operator = _ref2.operator,
-      operands = _ref2.operands,
-      options = _ref2.options;
-
+    operands = _ref2.operands,
+    options = _ref2.options;
   switch (operator) {
     case 'and':
       return andOperation(operands);
-
     case 'bt':
-      return betweenOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return betweenOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'eq':
-      return equalsOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return equalsOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'gt':
-      return greaterThanOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return greaterThanOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'gte':
-      return greaterThanOrEqualsOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return greaterThanOrEqualsOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'in':
-      return inOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return inOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'lt':
-      return lessThanOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return lessThanOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'lte':
-      return lessThanOrEqualsOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return lessThanOrEqualsOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'or':
       return orOperation(operands);
-
     case 'sw':
-      return startsWithOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return startsWithOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     case 'mt':
-      return matchesOperation.apply(void 0, [options].concat(_toConsumableArray(operands)));
-
+      return matchesOperation.apply(void 0, [options].concat((0, _toConsumableArray2["default"])(operands)));
     default:
-      return constant(true);
+      return (0, _lodashEs.constant)(true);
   }
 };
-
 var andOperation = function andOperation(expressions) {
-  var fns = map(expressions, compileExpression);
+  var fns = (0, _lodashEs.map)(expressions, compileExpression);
   return function (object, filters) {
-    return every(fns, function (fn) {
+    return (0, _lodashEs.every)(fns, function (fn) {
       return fn(object, filters);
     });
   };
 };
-
 var orOperation = function orOperation(expressions) {
-  var fns = map(expressions, compileExpression);
+  var fns = (0, _lodashEs.map)(expressions, compileExpression);
   return function (object, filters) {
-    return some(fns, function (fn) {
+    return (0, _lodashEs.some)(fns, function (fn) {
       return fn(object, filters);
     });
   };
 };
-
 var betweenOperation = function betweenOperation(options, lvalue, rvalueMin, rvalueMax) {
   return function (object, filters) {
     var left = object[lvalue];
-    var right1 = get(filters, rvalueMin);
-    var right2 = get(filters, rvalueMax); // If the filter value is empty and strict is not enabled we skip the filter
+    var right1 = (0, _immutable.get)(filters, rvalueMin);
+    var right2 = (0, _immutable.get)(filters, rvalueMax);
+    // If the filter value is empty and strict is not enabled we skip the filter
     // by returning true.
-
     if ((isNullOrEmpty(right1) || isNullOrEmpty(right2)) && !options.strict) {
       return true;
     }
-
     if (compare(right1, right2, options, typeof left) <= 0) {
       throw new Error("Invalid filter values for between operation of ".concat(rvalueMin, " and ") + "".concat(rvalueMax, ". Min ").concat(JSON.stringify(right1), " not less than max ") + JSON.stringify(right2) + (options.caseInsensitive ? ' (caseInsensitive)' : ''));
     }
-
     return compare(left, right1, options) <= 0 && compare(left, right2, options) > 0;
   };
 };
-
 var equalsOperation = function equalsOperation(options, lvalue, rvalue) {
   return function (object, filters) {
-    return skip(get(filters, rvalue), options) || compare(object[lvalue], get(filters, rvalue), options) === 0;
+    return skip((0, _immutable.get)(filters, rvalue), options) || compare(object[lvalue], (0, _immutable.get)(filters, rvalue), options) === 0;
   };
 };
-
 var greaterThanOperation = function greaterThanOperation(options, lvalue, rvalue) {
   return function (object, filters) {
-    return skip(get(filters, rvalue), options) || compare(object[lvalue], get(filters, rvalue), options) < 0;
+    return skip((0, _immutable.get)(filters, rvalue), options) || compare(object[lvalue], (0, _immutable.get)(filters, rvalue), options) < 0;
   };
 };
-
 var greaterThanOrEqualsOperation = function greaterThanOrEqualsOperation(options, lvalue, rvalue) {
   return function (object, filters) {
-    return skip(get(filters, rvalue), options) || compare(object[lvalue], get(filters, rvalue), options) <= 0;
+    return skip((0, _immutable.get)(filters, rvalue), options) || compare(object[lvalue], (0, _immutable.get)(filters, rvalue), options) <= 0;
   };
 };
-
 var inOperation = function inOperation(options, lvalue, rvalue) {
   return function (object, filters) {
     // If the filter value is [], null, undefined then we check for the strict
     // option, if strict always return false and if not strict always return
     // true (because we are effectively skipping this filter operation).
-    if (isNullOrEmpty(get(filters, rvalue)) && !isString(get(filters, rvalue))) {
+    if (isNullOrEmpty((0, _immutable.get)(filters, rvalue)) && !(0, _lodashEs.isString)((0, _immutable.get)(filters, rvalue))) {
       return !options.strict;
-    } // If we got a non-empty filter value that isn't an array (like a string)
+    }
+    // If we got a non-empty filter value that isn't an array (like a string)
     // we throw an error.
-
-
-    if (!isArray(get(filters, rvalue)) && !isImmutable(get(filters, rvalue))) {
-      throw new Error("Invalid filter value for in operation of ".concat(rvalue, " filter. Got ").concat(JSON.stringify(get(filters, rvalue)), ". Require an array."));
-    } // Finally perform the operation by checking the filter value for membership
+    if (!(0, _lodashEs.isArray)((0, _immutable.get)(filters, rvalue)) && !(0, _immutable.isImmutable)((0, _immutable.get)(filters, rvalue))) {
+      throw new Error("Invalid filter value for in operation of ".concat(rvalue, " filter. Got ").concat(JSON.stringify((0, _immutable.get)(filters, rvalue)), ". Require an array."));
+    }
+    // Finally perform the operation by checking the filter value for membership
     // of the object value.
-
-
-    return Seq(get(filters, rvalue)).some(function (v) {
-      return compare(get(object, lvalue), v, options) === 0;
+    return (0, _immutable.Seq)((0, _immutable.get)(filters, rvalue)).some(function (v) {
+      return compare((0, _immutable.get)(object, lvalue), v, options) === 0;
     });
   };
 };
-
 var lessThanOperation = function lessThanOperation(options, lvalue, rvalue) {
   return function (object, filters) {
-    return skip(get(filters, rvalue), options) || compare(object[lvalue], get(filters, rvalue), options) > 0;
+    return skip((0, _immutable.get)(filters, rvalue), options) || compare(object[lvalue], (0, _immutable.get)(filters, rvalue), options) > 0;
   };
 };
-
 var lessThanOrEqualsOperation = function lessThanOrEqualsOperation(options, lvalue, rvalue) {
   return function (object, filters) {
-    return skip(get(filters, rvalue), options) || compare(object[lvalue], get(filters, rvalue), options) >= 0;
+    return skip((0, _immutable.get)(filters, rvalue), options) || compare(object[lvalue], (0, _immutable.get)(filters, rvalue), options) >= 0;
   };
 };
-
 var startsWithOperation = function startsWithOperation(options, lvalue, rvalue) {
   var normalize = normalization(options);
   return function (object, filters) {
-    return isNullOrEmpty(get(filters, rvalue)) || object[lvalue] && normalize(object[lvalue]).startsWith(normalize(get(filters, rvalue)));
+    return isNullOrEmpty((0, _immutable.get)(filters, rvalue)) || object[lvalue] && normalize(object[lvalue]).startsWith(normalize((0, _immutable.get)(filters, rvalue)));
   };
 };
-
 var matchesOperation = function matchesOperation(options, lvalue, rvalue) {
   var normalize = normalization(options);
   return function (object, filters) {
-    return isNullOrEmpty(get(filters, rvalue)) || object[lvalue] && normalize(object[lvalue]).includes(normalize(get(filters, rvalue)));
+    return isNullOrEmpty((0, _immutable.get)(filters, rvalue)) || object[lvalue] && normalize(object[lvalue]).includes(normalize((0, _immutable.get)(filters, rvalue)));
   };
 };
-
 var skip = function skip(filterValue, options) {
   return isNullOrEmpty(filterValue) && !options.strict;
-}; // Helper that normalizes comparing values when one or both of the values is
-// falsy. Our convention is (any truthy) > '' > null > undefined.
-
+};
 
+// Helper that normalizes comparing values when one or both of the values is
+// falsy. Our convention is (any truthy) > '' > null > undefined.
 var compare = function compare(left, right, options) {
   var type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : typeof left;
   var normalize = normalization(options);
-
   if (nonNull(left) && nonNull(right)) {
     return normalize(right, type) > normalize(left, type) ? 1 : normalize(right, type) === normalize(left, type) ? 0 : -1;
   } else {
@@ -378,33 +329,32 @@ var compare = function compare(left, right, options) {
     return rightRank > leftRank ? 1 : rightRank === leftRank ? 0 : -1;
   }
 };
-
 var nonNull = function nonNull(v) {
   return v || v === 0 || v === false;
 };
-
 var normalization = function normalization(options) {
   return function (value, coerceType) {
     return options.caseInsensitive ? toLower(coerce(value, coerceType)) : coerce(value, coerceType);
   };
 };
-
 var isNullOrEmpty = function isNullOrEmpty(value) {
-  return isString(value) && isEmpty(value) || isArray(value) && isEmpty(value) || value === null || value === undefined;
+  return (0, _lodashEs.isString)(value) && (0, _lodashEs.isEmpty)(value) || (0, _lodashEs.isArray)(value) && (0, _lodashEs.isEmpty)(value) || value === null || value === undefined;
 };
-
 var coerce = function coerce(value, type) {
-  if ( // no-op if a type is not specified
-  !type || // return value if it is already the correct type
-  typeof value === type || // do not attempt to coerce null / undefined
-  value === null || typeof value === 'undefined' || // do not attempt to coerce to undefined or object (which type null returns)
+  if (
+  // no-op if a type is not specified
+  !type ||
+  // return value if it is already the correct type
+  typeof value === type ||
+  // do not attempt to coerce null / undefined
+  value === null || typeof value === 'undefined' ||
+  // do not attempt to coerce to undefined or object (which type null returns)
   type === 'undefined' || type === 'object') {
     return value;
   }
-
-  var valueType = typeof value; // if-else conditions below perform the actual type coercion, if a value is
+  var valueType = typeof value;
+  // if-else conditions below perform the actual type coercion, if a value is
   // not returned
-
   if (type === 'number' && valueType === 'string') {
     return parseInt(value);
   } else if (type === 'boolean' && valueType === 'string') {
@@ -414,12 +364,8 @@ var coerce = function coerce(value, type) {
       return false;
     }
   }
-
   throw new Error("Cannot coerce value ".concat(JSON.stringify(value), " to ").concat(type, "."));
 };
-
 var toLower = function toLower(value) {
-  return isString(value) ? value.toLocaleLowerCase() : value;
-};
-
-export { defineKqlQuery, defineFilter };
+  return (0, _lodashEs.isString)(value) ? value.toLocaleLowerCase() : value;
+};