@wavemaker-ai/react-runtime 1.0.0-rc.309

package/components/basic/search/providers.js

@@ -0,0 +1,415 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalDataProvider = exports.DataProvider = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _lodash = require("lodash");
+var _types = require("@wavemaker-ai/react-runtime/components/data/types");
+// import { DataSource } from "../../data/types";
+// Enhanced LocalDataProvider with React Native logic
+var LocalDataProvider = exports.LocalDataProvider = /*#__PURE__*/function () {
+  function LocalDataProvider() {
+    (0, _classCallCheck2["default"])(this, LocalDataProvider);
+  }
+  return (0, _createClass2["default"])(LocalDataProvider, [{
+    key: "createEmptyResult",
+    value: function createEmptyResult() {
+      return {
+        data: [],
+        hasMoreData: false,
+        isLastPage: true
+      };
+    }
+  }, {
+    key: "applyFilter",
+    value: function applyFilter(entry, queryText) {
+      entry = (0, _lodash.isNumber)(entry) ? entry.toString() : entry;
+      return (0, _lodash.includes)(entry, queryText);
+    }
+  }, {
+    key: "filter",
+    value: function filter(config) {
+      var _this = this;
+      var entries = config.dataset || [];
+      var queryText = typeof config.query === "string" ? config.query : "";
+      var searchKey = config.searchKey,
+        _config$casesensitive = config.casesensitive,
+        casesensitive = _config$casesensitive === void 0 ? false : _config$casesensitive,
+        matchMode = config.matchMode,
+        groupby = config.groupby,
+        limit = config.limit,
+        orderby = config.orderby;
+      var isCaseSensitive = matchMode && !(0, _lodash.includes)(matchMode, "ignorecase") ? true : casesensitive;
+      var filteredData = [];
+      return new Promise(function (resolve) {
+        // If searchkey is defined, then check for match string against each item in the dataset
+        if (searchKey) {
+          var keys = (0, _lodash.split)(searchKey, ",");
+          if (!entries.length) {
+            return resolve(_this.createEmptyResult());
+          }
+          var entryObj = entries[0];
+          entryObj = entryObj.hasOwnProperty("dataObject") ? entryObj["dataObject"] : entryObj;
+          var entryKeys = Object.keys(entryObj);
+          var hasEntry = keys.find(function (k) {
+            if (k.includes(".")) {
+              k = (0, _lodash.split)(k, ".")[0];
+            }
+            return entryKeys.includes(k);
+          });
+          if (!hasEntry) {
+            // Widget bound to query variable, searchkey is query or path params
+            return resolve({
+              data: entries,
+              hasMoreData: false,
+              isLastPage: true
+            });
+          }
+          filteredData = (0, _lodash.filter)(entries, function (item) {
+            return keys.some(function (key) {
+              var a = (0, _lodash.get)(item.dataObject || item, key);
+              var b = queryText;
+              if (!isCaseSensitive) {
+                a = (0, _lodash.toLower)(String(a));
+                b = (0, _lodash.toLower)(String(b));
+              }
+              return matchMode ? _this.applyMatchMode(String(a), String(b), matchMode) : _this.applyFilter(a, b);
+            });
+          });
+        } else {
+          // Local search on data with array of objects
+          if ((0, _lodash.isArray)(entries) && entries.length > 0) {
+            // Check if entries have dataObject property (normalized format)
+            var hasDataObject = entries[0] && entries[0].hasOwnProperty("dataObject");
+            if (hasDataObject) {
+              // Handle normalized dataset format
+              filteredData = (0, _lodash.filter)(entries, function (entry) {
+                var dataObj = entry.dataObject || entry;
+                var a = (0, _lodash.isString)(dataObj) ? dataObj : (0, _lodash.values)(dataObj).join(" ");
+                if (!isCaseSensitive) {
+                  a = (0, _lodash.toLower)(String(a));
+                  queryText = (0, _lodash.toLower)(String(queryText));
+                }
+                return matchMode ? _this.applyMatchMode(String(a), String(queryText), matchMode, groupby) : _this.applyFilter(a, queryText);
+              });
+            } else if ((0, _lodash.isObject)(entries[0])) {
+              // Handle regular object array
+              filteredData = (0, _lodash.filter)(entries, function (entry) {
+                var dataObj = entry.dataObject || entry;
+                var a = (0, _lodash.isString)(dataObj) ? dataObj : (0, _lodash.values)(dataObj).join(" ");
+                if (!isCaseSensitive) {
+                  a = (0, _lodash.toLower)(String(a));
+                  queryText = (0, _lodash.toLower)(String(queryText));
+                }
+                return matchMode ? _this.applyMatchMode(String(a), String(queryText), matchMode) : _this.applyFilter(a, queryText);
+              });
+            } else {
+              // Handle primitive values
+              filteredData = (0, _lodash.filter)(entries, function (entry) {
+                var entryValue = entry;
+                if (!isCaseSensitive) {
+                  entryValue = (0, _lodash.toLower)(String(entryValue));
+                  queryText = (0, _lodash.toLower)(String(queryText));
+                }
+                return matchMode ? _this.applyMatchMode(String(entryValue), String(queryText), matchMode) : _this.applyFilter(entryValue, queryText);
+              });
+            }
+          } else {
+            filteredData = (0, _lodash.filter)(entries, function (entry) {
+              var entryValue = entry;
+              if (!isCaseSensitive) {
+                entryValue = (0, _lodash.toLower)(String(entryValue));
+                queryText = (0, _lodash.toLower)(String(queryText));
+              }
+              return matchMode ? _this.applyMatchMode(String(entryValue), String(queryText), matchMode) : _this.applyFilter(entryValue, queryText);
+            });
+          }
+        }
+
+        // Apply orderby if provided
+        if (orderby && filteredData.length > 0) {
+          var _orderParts$, _orderParts$2;
+          var orderParts = (0, _lodash.split)(orderby, ":");
+          var orderField = (_orderParts$ = orderParts[0]) === null || _orderParts$ === void 0 ? void 0 : _orderParts$.trim();
+          var orderDirection = ((_orderParts$2 = orderParts[1]) === null || _orderParts$2 === void 0 ? void 0 : _orderParts$2.trim().toLowerCase()) || "asc";
+          if (orderField) {
+            filteredData = (0, _lodash.orderBy)(filteredData, function (item) {
+              // Handle normalized format with dataObject
+              var dataObj = item.dataObject || item;
+              var value = (0, _lodash.get)(dataObj, orderField);
+              // Handle numeric values for proper sorting
+              if ((0, _lodash.isNumber)(value)) {
+                return value;
+              }
+              // Convert to string for consistent sorting
+              return String(value || "").toLowerCase();
+            }, [orderDirection]);
+          }
+        }
+
+        // Apply limit if provided
+        if (limit && (0, _lodash.isNumber)(limit) && limit > 0) {
+          filteredData = filteredData.slice(0, limit);
+        }
+        resolve({
+          data: filteredData,
+          hasMoreData: false,
+          isLastPage: true
+        });
+      });
+    }
+
+    // Keep existing methods for backward compatibility (not used till now)
+  }, {
+    key: "performFiltering",
+    value: function performFiltering(entries, query, matchMode, datafield, searchKey) {
+      var isAllFieldsSearch = datafield === "All Fields" || !datafield;
+      if (isAllFieldsSearch) {
+        return this.filterAllFields(entries, query, matchMode);
+      }
+      return this.filterSpecificFields(entries, query, matchMode, datafield, searchKey);
+    }
+  }, {
+    key: "filterAllFields",
+    value: function filterAllFields(entries, query, matchMode) {
+      var _this2 = this;
+      if (this.isObjectArray(entries)) {
+        return entries === null || entries === void 0 ? void 0 : entries.filter(function (entry) {
+          return Object.keys(entry).some(function (key) {
+            return _this2.matchesField(entry[key], query, matchMode);
+          });
+        });
+      }
+      return entries === null || entries === void 0 ? void 0 : entries.filter(function (entry) {
+        return _this2.matchesField(entry, query, matchMode);
+      });
+    }
+  }, {
+    key: "filterSpecificFields",
+    value: function filterSpecificFields(entries, query, matchMode, datafield, searchKey) {
+      var _this3 = this;
+      var keys = searchKey ? searchKey.split(",") : [datafield];
+      return entries === null || entries === void 0 ? void 0 : entries.filter(function (item) {
+        return keys.some(function (key) {
+          if (!key || item[key] === undefined) return false;
+          return _this3.matchesField(item[key], query, matchMode);
+        });
+      });
+    }
+  }, {
+    key: "matchesField",
+    value: function matchesField(fieldValue, query, matchMode) {
+      if (fieldValue == null) return false;
+      var normalizedField = this.normalizeValue(fieldValue);
+      var normalizedQuery = this.normalizeValue(query);
+      return this.applyMatchMode(normalizedField, normalizedQuery, matchMode);
+    }
+  }, {
+    key: "normalizeValue",
+    value: function normalizeValue(value) {
+      var _value$toString$toLow;
+      return (_value$toString$toLow = value === null || value === void 0 ? void 0 : value.toString().toLowerCase()) !== null && _value$toString$toLow !== void 0 ? _value$toString$toLow : "";
+    }
+  }, {
+    key: "isObjectArray",
+    value: function isObjectArray(entries) {
+      return Array.isArray(entries) && entries.length > 0 && (0, _typeof2["default"])(entries[0]) === "object";
+    }
+  }, {
+    key: "applyMatchMode",
+    value: function applyMatchMode(entry, queryText, matchMode, groupby) {
+      if (!queryText) return true;
+      if (matchMode !== null && matchMode !== void 0 && matchMode.includes("start") && !(groupby && (0, _lodash.includes)(matchMode, "ignorecase"))) {
+        return entry.startsWith(queryText);
+      }
+      if (matchMode !== null && matchMode !== void 0 && matchMode.includes("end")) {
+        return entry.endsWith(queryText);
+      }
+      if (matchMode !== null && matchMode !== void 0 && matchMode.includes("exact")) {
+        return entry === queryText;
+      }
+      if (matchMode === "contains") {
+        return entry.toLowerCase().includes(queryText.toLowerCase());
+      }
+      return entry.includes(queryText);
+    }
+  }]);
+}(); // Enhanced DataProvider with React Native logic
+var DataProvider = exports.DataProvider = /*#__PURE__*/function () {
+  function DataProvider() {
+    (0, _classCallCheck2["default"])(this, DataProvider);
+    (0, _defineProperty2["default"])(this, "localDataProvider", new LocalDataProvider());
+  }
+  return (0, _createClass2["default"])(DataProvider, [{
+    key: "init",
+    value:
+    // Check if the variable is of type service variable and whether update is required
+    function init(component) {
+      var datasource = component === null || component === void 0 ? void 0 : component.datasource;
+      if (datasource) {
+        var _datasource$serviceIn, _datasource$serviceIn2;
+        return datasource.execute(_types.DataSource.Operation.IS_PAGEABLE) || ((_datasource$serviceIn = datasource === null || datasource === void 0 || (_datasource$serviceIn2 = datasource.serviceInfo) === null || _datasource$serviceIn2 === void 0 || (_datasource$serviceIn2 = _datasource$serviceIn2.parameters) === null || _datasource$serviceIn2 === void 0 ? void 0 : _datasource$serviceIn2.length) !== null && _datasource$serviceIn !== void 0 ? _datasource$serviceIn : 0) > 0;
+      }
+      return false;
+    }
+
+    // Setting the inputFields and invoking the variable for API calls
+  }, {
+    key: "invokeVariable",
+    value: function () {
+      var _invokeVariable = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(component, query) {
+        var paramsObj, datasource, dataSource;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              paramsObj = null;
+              if (component !== null && component !== void 0 && component.searchkey) {
+                component === null || component === void 0 || component.searchkey.split(",").forEach(function (k) {
+                  if (!paramsObj) {
+                    paramsObj = {};
+                  }
+                  paramsObj[k] = query;
+                });
+              }
+              datasource = component === null || component === void 0 ? void 0 : component.datasource;
+              if (!datasource) {
+                _context2.next = 8;
+                break;
+              }
+              if (datasource.category === "wm.LiveVariable") {
+                // datasource.setFilter(paramsObj);
+              } else {
+                datasource.setInput(paramsObj);
+              }
+              dataSource = datasource;
+              if (component !== null && component !== void 0 && component.onBeforeservicecall) {
+                component.onBeforeservicecall(component, paramsObj);
+              }
+              return _context2.abrupt("return", new Promise(/*#__PURE__*/function () {
+                var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(resolve, reject) {
+                  var result;
+                  return _regenerator["default"].wrap(function _callee$(_context) {
+                    while (1) switch (_context.prev = _context.next) {
+                      case 0:
+                        _context.prev = 0;
+                        _context.next = 3;
+                        return dataSource.execute(_types.DataSource.Operation.SEARCH_RECORDS, component);
+                      case 3:
+                        result = _context.sent;
+                        resolve((result === null || result === void 0 ? void 0 : result.data) || []);
+                        _context.next = 10;
+                        break;
+                      case 7:
+                        _context.prev = 7;
+                        _context.t0 = _context["catch"](0);
+                        resolve([]);
+                      case 10:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }, _callee, null, [[0, 7]]);
+                }));
+                return function (_x3, _x4) {
+                  return _ref.apply(this, arguments);
+                };
+              }()));
+            case 8:
+              return _context2.abrupt("return", Promise.resolve());
+            case 9:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function invokeVariable(_x, _x2) {
+        return _invokeVariable.apply(this, arguments);
+      }
+      return invokeVariable;
+    }()
+  }, {
+    key: "filter",
+    value: function () {
+      var _filter2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(config) {
+        var searchKey, keys, updateRequired, response, dataSet;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              searchKey = config.searchKey; // If searchkey is provided, check if we need to make an API call
+              if (!searchKey) {
+                _context3.next = 22;
+                break;
+              }
+              keys = (0, _lodash.split)(searchKey, ",");
+              if (!(keys.length && config.component)) {
+                _context3.next = 22;
+                break;
+              }
+              // Check if update is required for service variables
+              updateRequired = this.init(config.component);
+              if (!updateRequired) {
+                _context3.next = 22;
+                break;
+              }
+              _context3.prev = 6;
+              _context3.next = 9;
+              return this.invokeVariable(config.component, config.query || "");
+            case 9:
+              response = _context3.sent;
+              if (!response) {
+                _context3.next = 16;
+                break;
+              }
+              dataSet = response.dataSet || response;
+              if (!(0, _lodash.isEmpty)(dataSet)) {
+                _context3.next = 14;
+                break;
+              }
+              return _context3.abrupt("return", {
+                data: [],
+                hasMoreData: false,
+                isLastPage: true
+              });
+            case 14:
+              if ((0, _lodash.isObject)(dataSet) && !(0, _lodash.isArray)(dataSet)) {
+                dataSet = [dataSet];
+              }
+              return _context3.abrupt("return", {
+                data: dataSet,
+                hasMoreData: false,
+                isLastPage: true
+              });
+            case 16:
+              _context3.next = 22;
+              break;
+            case 18:
+              _context3.prev = 18;
+              _context3.t0 = _context3["catch"](6);
+              console.error("API call failed:", _context3.t0);
+              return _context3.abrupt("return", {
+                data: [],
+                hasMoreData: false,
+                isLastPage: true
+              });
+            case 22:
+              return _context3.abrupt("return", this.localDataProvider.filter(config));
+            case 23:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[6, 18]]);
+      }));
+      function filter(_x5) {
+        return _filter2.apply(this, arguments);
+      }
+      return filter;
+    }()
+  }]);
+}();

package/components/basic/spinner/index.d.ts

@@ -0,0 +1,74 @@
+import React from "react";
+import { WmSpinnerProps } from "./props";
+export declare const WmSpinner: React.MemoExoticComponent<(props: WmSpinnerProps) => import("react/jsx-runtime").JSX.Element>;
+/**
+ * The WmSpinner component is used to show a loading indicator, which can be an icon,
+ * an image, or a default circular progress bar. It can track service variables to
+ * automatically show/hide based on their loading state.
+ *
+ * - [Playground](https://react-components.wavemaker.ai/?path=/story/basic-spinner--showcase)
+ *
+ * - [Docs](https://react-components.wavemaker.ai/?path=/story/basic-spinner--docs)
+ *
+ * @param props - {@link WmSpinnerProps}
+ */
+declare const _default: React.ComponentType<{
+    caption?: string;
+    type?: string;
+    servicevariabletotrack?: string;
+    iconclass?: string;
+    iconsize?: string;
+    image?: string;
+    imagewidth?: string;
+    imageheight?: string;
+    id?: string;
+    standalone?: boolean;
+    ref?: React.RefObject<HTMLElement> | React.RefObject<null>;
+    animation?: string;
+    show?: boolean | string;
+    padding?: string;
+    margin?: string;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+    conditionalstyle?: React.CSSProperties;
+    conditionalclass?: string;
+    showindevice?: ("xs" | "sm" | "md" | "lg" | "all")[];
+    onClick?: (event?: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onDoubleClick?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseEnter?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseLeave?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseOver?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseOut?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onFocus?: (event: React.FocusEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onBlur?: (event: React.FocusEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeydown?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeyup?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeypress?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    eventCallback?: (eventName: string, data: any) => void;
+    forwardedRef?: React.ForwardedRef<any>;
+    viewParent?: any;
+    destroy?: ((names: string[]) => void) | ((formName?: string) => void);
+    hint?: string;
+    arialabel?: string;
+    tabindex?: number;
+    styles?: React.CSSProperties;
+    children?: React.ReactNode;
+    hidden?: boolean;
+    name?: string;
+    listener?: Record<string, any>;
+    "data-widget-id"?: string;
+    iswidget?: boolean | string;
+    deferload?: boolean | string;
+    "item-id"?: string;
+    datavalue?: any;
+    prefab?: boolean;
+    inbound?: Record<string, any>;
+    outbound?: Record<string, any>;
+    key?: string;
+    formfield?: boolean;
+    updateon?: string;
+    dataset?: any;
+    prefabName?: string;
+}>;
+export default _default;