@olenbetong/react-data-object-connect/dist/esm/ReactDataObjectConnect.js

import React, { useState, useEffect, useCallback, useRef } from 'react';

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

const events = ["AllowDeleteChanged", "AllowUpdateChanged", "AllowInsertChanged", "SaveFailed", "PartialDataLoaded", "DataLoadFailed", "FieldChanged", "RecordCreated", "RecordRefreshed", "RecordDeleting", "RecordDeleted", "AfterSave", "BeforeLoad", "BeforeSave", "CancelEdit", "CurrentIndexChanged", "DataLoaded", "DirtyChanged"];
function connect(dataObject) {
  let currentRowOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  return function connect(WrappedComponent) {
    function getDataObject() {
      return typeof dataObject === "string" ? window[dataObject] : dataObject;
    }

    const connector = class extends React.Component {
      constructor(props) {
        super(props);
        const initialState = {};
        const dataObject = getDataObject();

        if (currentRowOnly) {
          for (let field of dataObject.getFields()) {
            initialState[field.name] = null;
          }
        } else {
          initialState.data = [];
        }

        this.state = Object.assign({
          canDelete: dataObject.isDeleteAllowed(),
          canUpdate: dataObject.isUpdateAllowed(),
          canInsert: dataObject.isInsertAllowed(),
          currentIndex: dataObject.getCurrentIndex(),
          isDirty: dataObject.isDirty(),
          isDeleting: false,
          isLoading: dataObject.isDataLoading() === true,
          isSaving: false,
          loadError: null,
          saveFailed: false
        }, initialState);
        this.handleAfterSave = this.handleAfterSave.bind(this);
        this.handleAllowDeleteChanged = this.handleAllowDeleteChanged.bind(this);
        this.handleAllowInsertChanged = this.handleAllowInsertChanged.bind(this);
        this.handleAllowUpdateChanged = this.handleAllowUpdateChanged.bind(this);
        this.handleBeforeLoad = this.handleBeforeLoad.bind(this);
        this.handleBeforeSave = this.handleBeforeSave.bind(this);
        this.handleCancelEdit = this.handleCancelEdit.bind(this);
        this.handleCurrentIndexChanged = this.handleCurrentIndexChanged.bind(this);
        this.handleDataLoaded = this.handleDataLoaded.bind(this);
        this.handleDataLoadFailed = this.handleDataLoadFailed.bind(this);
        this.handleDirtyChanged = this.handleDirtyChanged.bind(this);
        this.handlePartialDataLoaded = this.handlePartialDataLoaded.bind(this);
        this.handleRecordDeleting = this.handleRecordDeleting.bind(this);
        this.handleRecordDeleted = this.handleRecordDeleted.bind(this);
        this.handleSaveFailed = this.handleSaveFailed.bind(this);
        this.setFieldValue = this.setFieldValue.bind(this);
        this.setFieldValues = this.setFieldValues.bind(this);
        this.updateData = this.updateData.bind(this);
        this.handleFieldChanged = this.updateData;
        this.handleRecordCreated = this.updateData;
        this.handleRecordRefreshed = this.updateData;
      }

      componentDidMount() {
        const dataObject = getDataObject();

        for (let event of events) {
          dataObject.attachEvent("on" + event, this["handle" + event]);
        }

        this.updateData();
      }

      componentWillUnmount() {
        const dataObject = getDataObject();

        for (let event of events) {
          dataObject.detachEvent("on" + event, this["handle" + event]);
        }
      }

      cancelEdit() {
        getDataObject().cancelEdit();
      }

      deleteRow(idx) {
        const dataObject = getDataObject();
        return new Promise(resolve => {
          const callback = (error, data) => {
            resolve({
              data,
              error
            });
          };

          if (currentRowOnly) {
            dataObject.deleteCurrentRow(callback);
          } else {
            dataObject.deleteRow(idx, callback);
          }
        });
      }

      endEdit(callback) {
        const dataObject = getDataObject();
        return new Promise(resolve => {
          dataObject.endEdit((error, data) => {
            "function" === typeof callback && callback(error, data);
            resolve({
              data,
              error
            });
          });
        });
      }

      updateData() {
        let otherState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        const dataObject = getDataObject();

        if (currentRowOnly) {
          const record = dataObject.currentRow();
          this.setState(Object.assign(record, otherState));
        } else {
          const data = dataObject.getData();
          const current = dataObject.currentRow();
          this.setState(Object.assign({
            current,
            data
          }, otherState));
        }
      }

      handleAllowDeleteChanged(allowed) {
        this.setState({
          canDelete: allowed
        });
      }

      handleAllowUpdateChanged(allowed) {
        this.setState({
          canUpdate: allowed
        });
      }

      handleAllowInsertChanged(allowed) {
        this.setState({
          canInsert: allowed
        });
      }

      handleSaveFailed() {
        this.setState({
          saveFailed: true
        });
      }

      handlePartialDataLoaded() {
        return null;
      }

      handleDataLoadFailed(loadError) {
        if (loadError) {
          this.setState({
            isLoading: false,
            loadError
          });
        } else {
          this.setState({
            isLoading: false
          });
        }
      }

      handleRecordDeleting() {
        this.setState({
          isDeleting: true
        });
      }

      handleRecordDeleted() {
        this.updateData({
          isDeleting: false
        });
      }

      handleAfterSave() {
        this.updateData({
          isSaving: false
        });
      }

      handleBeforeLoad() {
        this.setState({
          isLoading: true
        });
      }

      handleBeforeSave() {
        this.setState({
          isSaving: true,
          saveFailed: false
        });
      }

      handleCancelEdit() {
        this.updateData({
          isSaving: false
        });
      }

      handleCurrentIndexChanged(currentIndex) {
        if (currentRowOnly) {
          this.updateData();
        } else {
          this.updateData();
          this.setState({
            currentIndex
          });
        }
      }

      handleDataLoaded() {
        this.updateData({
          isLoading: false,
          isSaving: false,
          isDeleting: false,
          saveFailed: false
        });
      }

      handleDirtyChanged() {
        this.setState({
          isDirty: getDataObject().isDirty()
        });
      }

      refreshData(callback) {
        const dataObject = getDataObject();
        return new Promise(resolve => {
          dataObject.refreshDataSource((error, data) => {
            "function" === typeof callback && callback(error, data);
            resolve({
              data,
              error
            });
          });
        });
      }

      refreshRow(callback) {
        const dataObject = getDataObject();
        return new Promise(resolve => {
          dataObject.refreshCurrentRow((error, data) => {
            "function" === typeof callback && callback(error, data);
            resolve({
              data,
              error
            });
          });
        });
      }

      setFieldValue(name, value) {
        getDataObject().currentRow(name, value);
        this.updateData();
      }

      setFieldValues(fields) {
        const dataObject = getDataObject();

        for (let field in fields) {
          if (Object.prototype.hasOwnProperty.call(fields, field)) {
            dataObject.currentRow(field, fields[field]);
          }
        }

        this.updateData();
      }

      setCurrentIndex(idx) {
        getDataObject().setCurrentIndex(idx);
      }

      setParameter() {
        getDataObject().setParameter(...arguments);
      }

      render() {
        return React.createElement(WrappedComponent, _extends({}, this.state, {
          onCancelEdit: this.cancelEdit,
          onCurrentIndexChange: this.setCurrentIndex,
          onDeleteRow: this.deleteRow,
          onEndEdit: this.endEdit,
          onFieldChange: this.setFieldValue,
          onFieldsChange: this.setFieldValues,
          onRefreshData: this.refreshData,
          onRefreshRow: this.refreshRow,
          onSetParameter: this.setParameter
        }, this.props));
      }

    };

    function getDisplayName() {
      return WrappedComponent.displayName || WrappedComponent.name || "Component";
    }

    connector.displayName = typeof dataObject === "string" ? dataObject : dataObject.getDataSourceId();
    connector.displayName += "(".concat(getDisplayName(), ")");
    return connector;
  };
}
const properties = ["onCancelEdit", "onCurrentIndexChange", "onEndEdit", "onDeleteRow", "onFieldChange", "onFieldsChange", "onRefreshData", "onRefreshRow", "onSetParameter", "canDelete", "canUpdate", "canInsert", "currentIndex", "isDirty", "isDeleting", "isLoading", "isSaving", "loadError", "saveFailed"];
const connectRow = dataObject => connect(dataObject, true);

function getData(dataObject, filter) {
  const {
    data
  } = window.af;
  const dataHandler = new data.DataProviderHandler({
    dataSourceId: dataObject.getDataSourceId(),
    timeout: 30000
  });
  const fields = dataObject.getFields();
  return new Promise((resolve, reject) => {
    const filterData = {
      filterString: "",
      whereClause: typeof filter === "string" ? filter : "",
      whereObject: typeof filter === "object" ? filter : null
    };
    dataHandler.retrieve(filterData, function (error, data) {
      if (error !== null) {
        reject(error);
      } else {
        const records = [];

        for (let item of data) {
          const record = {};

          for (let i = 0; i < item.length; i++) {
            record[fields[i].name] = item[i];
          }

          records.push(record);
        }

        resolve(records);
      }
    });
  });
}

function useCurrentIndex(dataObject) {
  const [index, setIndex] = useState(dataObject.getCurrentIndex());
  useEffect(() => {
    dataObject.attachEvent("onCurrentIndexChanged", setIndex);
    setIndex(dataObject.getCurrentIndex());
    return () => dataObject.detachEvent("onCurrentIndexChanged", setIndex);
  }, [dataObject]);
  return index;
}

// A resusable array containing all data object events that should trigger an update
var dataUpdateEvents = ["onFieldChanged", "onRecordCreated", "onRecordDeleted", "onRecordRefreshed", "onAfterSave", "onCancelEdit", "onDataLoaded", "onPartialDataLoaded"];

function useCurrentRow(dataObject) {
  const [record, setRecord] = useState(dataObject.currentRow() || {});
  const updateRecord = useCallback(() => setRecord(dataObject.currentRow()), [dataObject]);
  useEffect(() => {
    const recordUpdateEvents = ["onCurrentIndexChanged", ...dataUpdateEvents];
    recordUpdateEvents.forEach(event => dataObject.attachEvent(event, updateRecord));
    updateRecord();
    return () => recordUpdateEvents.forEach(event => dataObject.detachEvent(event, updateRecord));
  }, [dataObject, updateRecord]);
  return record;
}

function useData(dataObject) {
  const [data, setData] = useState(dataObject.getData());
  const updateData = useCallback(() => {
    const data = dataObject.getData(); // If current row is dirty, getData will still return the saved record

    const idx = dataObject.getCurrentIndex();

    if (idx >= 0) {
      data[idx] = dataObject.currentRow();
    }

    setData(data);
  }, [dataObject]);
  useEffect(() => {
    dataUpdateEvents.forEach(event => dataObject.attachEvent(event, updateData));
    updateData();
    return () => dataUpdateEvents.forEach(event => dataObject.detachEvent(event, updateData));
  }, [dataObject, updateData]);
  return data;
}

function useDataLength(dataObject) {
  const [length, setLength] = useState(() => dataObject.getDataLength());
  useEffect(() => {
    function update() {
      setLength(dataObject.getDataLength());
    }

    dataObject.attachEvent("onRecordCreated", update);
    dataObject.attachEvent("onRecordDeleted", update);
    dataObject.attachEvent("onDataLoaded", update);
    dataObject.attachEvent("onPartialDataLoaded", update);
    update();
    return () => {
      dataObject.detachEvent("onRecordCreated", update);
      dataObject.detachEvent("onRecordDeleted", update);
      dataObject.detachEvent("onDataLoaded", update);
      dataObject.detachEvent("onPartialDataLoaded", update);
    };
  }, [dataObject]);
  return length;
}

var isArray = Array.isArray;
var keyList = Object.keys;
var hasProp = Object.prototype.hasOwnProperty;

var fastDeepEqual = function equal(a, b) {
  if (a === b) return true;

  if (a && b && typeof a == 'object' && typeof b == 'object') {
    var arrA = isArray(a)
      , arrB = isArray(b)
      , i
      , length
      , key;

    if (arrA && arrB) {
      length = a.length;
      if (length != b.length) return false;
      for (i = length; i-- !== 0;)
        if (!equal(a[i], b[i])) return false;
      return true;
    }

    if (arrA != arrB) return false;

    var dateA = a instanceof Date
      , dateB = b instanceof Date;
    if (dateA != dateB) return false;
    if (dateA && dateB) return a.getTime() == b.getTime();

    var regexpA = a instanceof RegExp
      , regexpB = b instanceof RegExp;
    if (regexpA != regexpB) return false;
    if (regexpA && regexpB) return a.toString() == b.toString();

    var keys = keyList(a);
    length = keys.length;

    if (length !== keyList(b).length)
      return false;

    for (i = length; i-- !== 0;)
      if (!hasProp.call(b, keys[i])) return false;

    for (i = length; i-- !== 0;) {
      key = keys[i];
      if (!equal(a[key], b[key])) return false;
    }

    return true;
  }

  return a!==a && b!==b;
};

function useFilter(dataObject, filter) {
  let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "filterString";
  useEffect(() => {
    const current = dataObject.getParameter(type);

    if (filter !== false) {
      if (!fastDeepEqual(current, filter) || !dataObject.isDataLoaded() && !dataObject.isDataLoading()) {
        dataObject.setParameter(type, filter);
        dataObject.refreshDataSource();
      }
    }
  }, [dataObject, filter, type]);
}

function useDataWithFilter(dataObject, filter) {
  let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "filterString";
  const data = useData(dataObject);
  useFilter(dataObject, filter, type);
  return data;
}

function useDirty(dataObject) {
  const [isDirty, setDirty] = useState(dataObject.isDirty() || false);
  useEffect(() => {
    dataObject.attachEvent("onDirtyChanged", setDirty);
    setDirty(dataObject.isDirty());
    return () => {
      dataObject.detachEvent("onDirtyChanged", setDirty);
    };
  }, [dataObject]);
  return isDirty;
}

function useError(dataObject) {
  const [loadError, setError] = useState(null);
  useEffect(() => {
    dataObject.attachEvent("onDataLoadFailed", setError);
    return () => {
      dataObject.detachEvent("onDataLoadFailed", setError);
    };
  }, [dataObject]);
  return loadError;
}

function useFetchData(dataObject, filter) {
  const [data, setData] = useState([]);
  const [shouldUpdate, setShouldUpdate] = useState(false);
  const [isLoading, setIsLoading] = useState(filter !== false);
  const refresh = useCallback(() => {
    setShouldUpdate(shouldUpdate => !shouldUpdate);
  }, []);
  const refreshRows = useCallback(function (filter) {
    let idField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "PrimKey";
    getData(dataObject, filter).then(records => {
      let newData = [...data];

      for (let record of records) {
        for (let i = 0; i < newData.length; i++) {
          const current = newData[i];

          if (current[idField] === record[idField]) {
            newData[i] = record;
          }
        }
      }

      setData(newData);
    });
  }, [dataObject, data]);
  useEffect(() => {
    let isCancelled = false;

    if (filter !== false) {
      setIsLoading(true);
      getData(dataObject, filter).then(data => {
        if (!isCancelled) {
          if (data.length > 0) {
            setData(data);
          } else {
            setData([]);
          }

          setIsLoading(false);
        }
      });
    }

    return () => isCancelled = true;
  }, [dataObject, filter, shouldUpdate]);
  return {
    data,
    refresh,
    refreshRows,
    isLoading
  };
}

function useFetchRecord(dataObject, filter) {
  const {
    isLoading,
    data,
    refresh
  } = useFetchData(dataObject, filter);
  const record = data.length > 0 ? data[0] : {};
  return {
    record,
    refresh,
    isLoading
  };
}

function useLoading(dataObject) {
  const [isLoading, setLoading] = useState(dataObject.isDataLoading());

  function setIsLoading() {
    setLoading(true);
  }

  function setIsNotLoading() {
    setLoading(false);
  }

  useEffect(() => {
    dataObject.attachEvent("onBeforeLoad", setIsLoading);
    dataObject.attachEvent("onDataLoaded", setIsNotLoading);
    dataObject.attachEvent("onDataLoadFailed", setIsNotLoading);
    dataObject.attachEvent("onPartialDataLoaded", setIsNotLoading);
    setLoading(dataObject.isDataLoading());
    return () => {
      dataObject.detachEvent("onBeforeLoad", setIsLoading);
      dataObject.detachEvent("onDataLoaded", setIsNotLoading);
      dataObject.detachEvent("onDataLoadFailed", setIsNotLoading);
      dataObject.detachEvent("onPartialDataLoaded", setIsNotLoading);
    };
  }, [dataObject]);
  return isLoading;
}

function getCurrentData(dataObject) {
  return dataObject.getPagingComponent().getCurrentData() || [];
}

function usePagedData(dataObject) {
  const [currentData, setCurrentData] = useState(() => getCurrentData(dataObject));
  useEffect(() => {
    function updateData() {
      setCurrentData([...getCurrentData(dataObject)]);
    }

    dataUpdateEvents.forEach(event => dataObject.attachEvent(event, updateData));
    const pagingComponent = dataObject.getPagingComponent();
    pagingComponent.attach("on", "pageChange", updateData);
    pagingComponent.attach("on", "pageRefresh", updateData);
    updateData();
    return () => {
      dataUpdateEvents.forEach(event => dataObject.detachEvent(event, updateData));
      pagingComponent.detach("on", "pageChange", updateData);
      pagingComponent.detach("on", "pageRefresh", updateData);
    };
  }, [dataObject]);
  return currentData;
}

function usePagedDataWithFilter(dataObject, filter) {
  let type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "filterString";
  const data = usePagedData(dataObject);
  useFilter(dataObject, filter, type);
  return data;
}

function usePaging(dataObject) {
  const [page, setPage] = useState(() => dataObject.getPagingComponent().getCurrentPage());
  const [pageCount, setPageCount] = useState(() => dataObject.getPagingComponent().getPageCount());
  useEffect(() => {
    const paging = dataObject.getPagingComponent();

    const updateCurrentPage = () => setPage(paging.getCurrentPage());

    const updatePageCount = () => setPageCount(paging.getPageCount());

    paging.attach("on", "pageChange", updateCurrentPage);
    paging.attach("on", "pageCountChange", updatePageCount);
    return () => {
      paging.detach("on", "pageChange", updateCurrentPage);
      paging.detach("on", "pageCountChange", updatePageCount);
    };
  }, [dataObject]);
  return {
    page,
    pageCount,
    changePage: dataObject.getPagingComponent().changePage
  };
}

function useParameter(dataObject, parameter) {
  const [value, setValue] = useState(() => dataObject.getParameter(parameter));
  useEffect(() => {
    function update() {
      setValue(dataObject.getParameter(parameter));
    }

    dataObject.attachEvent("onParameterUpdated", update);
    update();
    return () => {
      dataObject.detachEvent("onParameterUpdated", update);
    };
  }, [dataObject, parameter]);
  return value;
}

function usePermissions(dataObject) {
  const [allowDelete, setAllowDelete] = useState(dataObject.isDeleteAllowed());
  const [allowInsert, setAllowInsert] = useState(dataObject.isInsertAllowed());
  const [allowUpdate, setAllowUpdate] = useState(dataObject.isUpdateAllowed());
  useEffect(() => {
    const updateAllowDelete = () => setAllowDelete(dataObject.isDeleteAllowed());

    const updateAllowInsert = () => setAllowInsert(dataObject.isInsertAllowed());

    const updateAllowUpdate = () => setAllowUpdate(dataObject.isUpdateAllowed());

    dataObject.attachEvent("onAllowDeleteChanged", updateAllowDelete);
    dataObject.attachEvent("onAllowInsertChanged", updateAllowInsert);
    dataObject.attachEvent("onAllowUpdateChanged", updateAllowUpdate);
    updateAllowDelete();
    updateAllowInsert();
    updateAllowUpdate();
    return () => {
      dataObject.detachEvent("onAllowDeleteChanged", updateAllowDelete);
      dataObject.detachEvent("onAllowInsertChanged", updateAllowInsert);
      dataObject.detachEvent("onAllowUpdateChanged", updateAllowUpdate);
    };
  }, [dataObject]);
  return {
    allowDelete,
    allowInsert,
    allowUpdate
  };
}

function useDeepCompareMemoize(value) {
  const ref = useRef();

  if (!fastDeepEqual(value, ref.current)) {
    ref.current = value;
  }

  return ref.current;
}

function useDeepCompareEffect(callback, dependencies) {
  useEffect(callback, useDeepCompareMemoize(dependencies));
}
function useProcedure(procedure, params) {
  const [data, setData] = useState([]);
  const [error, setError] = useState(null);
  const [isExecuting, setIsExecuting] = useState(false);
  useDeepCompareEffect(() => {
    let isAborted = false;

    if (params && procedure) {
      setIsExecuting(true);
      procedure.execute(params, (err, data) => {
        if (!isAborted) {
          setIsExecuting(false);

          if (err) {
            setError(err);
            setData([]);
          } else {
            setData(data);
            setError(null);
          }
        }
      });
    }

    return () => {
      isAborted = true;
    }; // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [procedure, params]);
  return {
    data,
    error,
    isExecuting
  };
}

function useStatus(dataObject) {
  const [isSaving, setIsSaving] = useState(false);
  const [isDeleting, setIsDeleting] = useState(false);

  function setSaving() {
    setIsSaving(true);
  }

  function setNotSaving() {
    setIsSaving(false);
  }

  function setDeleting() {
    setIsDeleting(true);
  }

  function setNotDeleting() {
    setIsDeleting(false);
  }

  useEffect(() => {
    dataObject.attachEvent("onBeforeSave", setSaving);
    dataObject.attachEvent("onAfterSave", setNotSaving);
    dataObject.attachEvent("onSaveFailed", setNotSaving);
    dataObject.attachEvent("onRecordDeleting", setDeleting);
    dataObject.attachEvent("onRecordDeleted", setNotDeleting);
    return () => {
      dataObject.detachEvent("onBeforeSave", setSaving);
      dataObject.detachEvent("onAfterSave", setNotSaving);
      dataObject.detachEvent("onSaveFailed", setNotSaving);
      dataObject.detachEvent("onRecordDeleting", setDeleting);
      dataObject.detachEvent("onRecordDeleted", setNotDeleting);
    };
  }, [dataObject]);
  return {
    isDeleting,
    isSaving
  };
}

class SimpleDataHandler {
  constructor(dataObject) {
    const {
      data
    } = window.af;
    this.dataObject = dataObject;
    this.fields = dataObject.getFields();
    this.dataHandler = new data.DataProviderHandler({
      dataSourceId: dataObject.getDataSourceId(),
      timeout: 30000
    });
  }

  arrayRecordToObject(record) {
    const obj = {};

    for (let i = 0; i < record.length; i++) {
      obj[this.fields[i].name] = record[i];
    }

    return obj;
  }

  createRecord(record) {
    return new Promise((resolve, reject) => {
      this.dataHandler.create(record, (error, data) => {
        if (error !== null) {
          reject(error);
        } else {
          resolve(this.arrayRecordToObject(data));
        }
      });
    });
  }

  deleteRecord(filter) {
    return new Promise((resolve, reject) => {
      this.dataHandler.destroy(filter, (error, data) => {
        if (error !== null) {
          reject(error);
        } else {
          resolve(this.arrayRecordToObject(data));
        }
      });
    });
  }

  getData(filter) {
    return new Promise((resolve, reject) => {
      const filterData = {
        filterString: "",
        whereClause: typeof filter === "string" ? filter : "",
        whereObject: typeof filter === "object" ? filter : null
      };
      this.dataHandler.retrieve(filterData, (error, data) => {
        if (error !== null) {
          reject(error);
        } else {
          const records = [];

          for (let item of data) {
            records.push(this.arrayRecordToObject(item));
          }

          resolve(records);
        }
      });
    });
  }

  updateRecord(record) {
    return new Promise((resolve, reject) => {
      this.dataHandler.update(record, (error, data) => {
        if (error !== null) {
          reject(error);
        } else {
          resolve(this.arrayRecordToObject(data));
        }
      });
    });
  }

}

export { SimpleDataHandler, connect, connectRow, properties as connectedProperties, getData, useCurrentIndex, useCurrentRow, useData, useDataLength, useDataWithFilter, useDirty, useError, useFetchData, useFetchRecord, useFilter, useLoading, usePagedData, usePagedDataWithFilter, usePaging, useParameter, usePermissions, useProcedure, useStatus };