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

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

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
  };
}

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