@drieam/common/es/index.js

Default Drieam api wrapper

import React from 'react';
import ReactDOM from 'react-dom';
import get from 'lodash/get';
import camelCase from 'lodash/camelCase';
import 'lodash/isNil';
import ResizeObserver from 'resize-observer-polyfill';
import { defaultOptions as defaultOptions$1, SAVE_ENTITY_FAILED, DELETE_ENTITY_FAILED, DELETE_ENTITY_SUCCESS, SAVE_LIST_SUCCESS, SAVE_ENTITY_SUCCESS, apiMiddlewares } from '@drieam/api';
import Notification from 'antd/lib/notification';

function bytesToSize(bytes) {
  var sizes = ["Bytes", "KB", "MB", "GB", "TB"];
  if (bytes === 0) return "0 Byte";
  var i = Math.floor(Math.log(bytes) / Math.log(1024));
  return Math.round(bytes / Math.pow(1024, i)) + " " + sizes[i];
}

function parseData(data) {
  var re = /!\*{3}\s(.*)?\s\*{3}!/g;
  var m = null;
  var sb = []; // eslint-disable-next-line no-cond-assign

  while (m = re.exec(data)) {
    sb.push(m[1]);
  }

  return sb.join("<br />");
}

var onSuccess = function onSuccess(url) {
  return function (data) {
    document.body.insertAdjacentHTML("beforeend", "<div>\n  <h3>" + url + "</h3>\n  <h4>" + bytesToSize(new Blob([data]).size) + "</h4>\n  <code>\n    " + parseData(data) + "\n  </code>\n</div>");
  };
};

function visualizeDependencies() {
  var collection = document.getElementsByTagName("script");
  var urls = [];

  for (var i = 0; i < collection.length; i += 1) {
    urls.push(collection[i].getAttribute("src"));
  }

  urls.forEach(function (url) {
    fetch(url, {
      headers: {
        "Content-Type": " text/plain"
      }
    }).then(function (response) {
      return response.text();
    }).then(onSuccess(url));
  });
}

var debug = {
  visualizeDependencies: visualizeDependencies
};

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

// Inspired by
// https://github.com/atomicjolt/lti_starter_app/blob/d5a59a04e7e14cb28d08dc8fba2a735b3831b573/client/common/libs/resize_iframe.js
// https://github.com/atomicjolt/atomic-fuel/blob/73b8718bbc2a6d3bd991fab2bfdd711c79f6d7bd/src/communications/communicator.js
function broadcastMessage(message, targetOrigin) {
  if (targetOrigin === void 0) {
    targetOrigin = "*";
  } // eslint-disable-next-line no-restricted-globals


  parent.postMessage(message, targetOrigin);
}

function postLtiFrameResize(height) {
  if (height > 0) {
    var message = {
      height: height,
      subject: "lti.frameResize"
    };
    broadcastMessage(JSON.stringify(message));
  }
}

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

var _assign = function __assign() {
  _assign = Object.assign || function __assign(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
      s = arguments[i];

      for (var p in s) {
        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
      }
    }

    return t;
  };

  return _assign.apply(this, arguments);
};
function __values(o) {
  var s = typeof Symbol === "function" && Symbol.iterator,
      m = s && o[s],
      i = 0;
  if (m) return m.call(o);
  if (o && typeof o.length === "number") return {
    next: function next() {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
      r,
      ar = [],
      e;

  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {
      ar.push(r.value);
    }
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }

  return ar;
}
function __spread() {
  for (var ar = [], i = 0; i < arguments.length; i++) {
    ar = ar.concat(__read(arguments[i]));
  }

  return ar;
}

function filterByDataAttributes(name) {
  return /data/.test(name);
}

function dataAttributesReducer(element) {
  return function (current, prev) {
    var _a;

    var name = /data-(.*)/.exec(prev);

    if (!name) {
      return current;
    }

    return _assign(_assign({}, current), (_a = {}, _a[camelCase(name[1])] = element.getAttribute(prev), _a));
  };
}
/**
 * get attributes of a DOM element
 */


function getAttributes(element) {
  if (!element) return {};
  return element.getAttributeNames().filter(filterByDataAttributes).reduce(dataAttributesReducer(element), {});
}
/**
 * Render a React Container in the specific element
 * @param Container
 * @param element
 */


function render(Container, element) {
  var e_1, _a;

  if (!element) {
    console.error("Not Found");
    return;
  }

  var elements = element instanceof HTMLCollection ? Array.from(element) : [element];

  try {
    // eslint-disable-next-line no-restricted-syntax
    for (var elements_1 = __values(elements), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
      var e = elements_1_1.value;
      var attr = getAttributes(e);
      ReactDOM.render( /*#__PURE__*/React.createElement(Container, _assign({}, attr)), e);
    }
  } catch (e_1_1) {
    e_1 = {
      error: e_1_1
    };
  } finally {
    try {
      if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
    } finally {
      if (e_1) throw e_1.error;
    }
  }
}

var iframeResizeObserver = new ResizeObserver(function (entries) {
  var e_1, _a;

  try {
    // eslint-disable-next-line no-restricted-syntax
    for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
      var entry = entries_1_1.value;
      var height = entry.contentRect.height;
      postLtiFrameResize(height);
    }
  } catch (e_1_1) {
    e_1 = {
      error: e_1_1
    };
  } finally {
    try {
      if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
    } finally {
      if (e_1) throw e_1.error;
    }
  }
});

function observeIframeResize(selector) {
  if (selector === void 0) {
    selector = "[data-react-class]";
  }

  document.querySelectorAll(selector).forEach(function (element) {
    return iframeResizeObserver.observe(element);
  });
}

if (Element.prototype.getAttributeNames === undefined) {
  Element.prototype.getAttributeNames = function getAttributeNames() {
    var attributes = this.attributes;
    var length = attributes.length; // tslint:disable-next-line

    var result = new Array(length);

    for (var i = 0; i < length; i += 1) {
      result[i] = attributes[i].name;
    }

    return result;
  };
}

function getCSRFToken() {
  var meta = document.head.querySelector("meta[name=csrf-token]");
  return meta ? meta.getAttribute("content") : "";
}

function getLocale() {
  return document.documentElement.getAttribute("lang") || "en";
}

function getTimeZone() {
  return document.body.dataset.timeZone || "Europe/Amsterdam";
}

var dom = {
  iframeResizeObserver: iframeResizeObserver,
  observeIframeResize: observeIframeResize,
  broadcastMessage: broadcastMessage,
  postLtiFrameResize: postLtiFrameResize,
  render: render,
  getAttributes: getAttributes,
  getCSRFToken: getCSRFToken,
  getLocale: getLocale,
  getTimeZone: getTimeZone
};

var utils = {
  debug: debug,
  dom: dom,
  getDisplayName: getDisplayName
};

var defaultOptions = _assign(_assign({}, defaultOptions$1), {
  // Enables ErrorHandlingMiddleware (Default: Enable).
  withErrorHandler: true,
  // Default CSRF Token from DOM.
  csrfToken: utils.dom.getCSRFToken(),
  // ErrorMiddelware
  toasts: {
    offline: {
      duration: 0,
      message: "Not connected."
    },
    save: {
      message: "Saved success."
    },
    delete: {
      message: "Deleted success."
    }
  }
});

var APP_ONLINE = "APP_ONLINE";

var defaultNotify = Notification;
var ENTITY_ACTIONS = [SAVE_ENTITY_SUCCESS, SAVE_ENTITY_FAILED, SAVE_LIST_SUCCESS, DELETE_ENTITY_SUCCESS, DELETE_ENTITY_FAILED];

function errorHandlingMiddleware(parentOptions, notificationApi) {
  if (notificationApi === void 0) {
    notificationApi = defaultNotify;
  }

  return function (store) {
    function dispatchOnline() {
      store.dispatch({
        type: APP_ONLINE,
        payload: window.navigator.onLine
      });
    }

    window.addEventListener("online", dispatchOnline);
    window.addEventListener("offline", dispatchOnline);
    window.addEventListener("load", dispatchOnline);
    return function (next) {
      return function (action) {
        var opts = _assign(_assign({}, parentOptions), action.options);

        if (action.type === APP_ONLINE) {
          var onlineAction = action;

          if (onlineAction.payload) {
            notificationApi.close("offline");
          } else {
            notificationApi.error(_assign(_assign({}, get(parentOptions, "toasts.offline")), {
              key: "offline"
            }));
          }
        } else if (ENTITY_ACTIONS.includes(action.type)) {
          var toasts = opts.toasts;

          switch (action.type) {
            case SAVE_ENTITY_SUCCESS:
            case SAVE_LIST_SUCCESS:
              if (!get(toasts, "save")) {
                break;
              }

              notificationApi.success(toasts.save);
              break;

            case DELETE_ENTITY_SUCCESS:
              if (!get(toasts, "delete")) {
                break;
              }

              notificationApi.success(toasts.delete);
              break;

            case DELETE_ENTITY_FAILED:
            case SAVE_ENTITY_FAILED:
              if (!toasts.failed) {
                break;
              }

              notificationApi.error(toasts.failed);
              break;
          }
        }

        return next(action);
      };
    };
  };
}

function getCommonMiddlewares(apiRoutes, options) {
  if (options === void 0) {
    options = defaultOptions;
  }

  var apiOptions = _assign(_assign({}, defaultOptions), options);

  return __spread(apiMiddlewares(apiRoutes, apiOptions), [apiOptions.withErrorHandler && errorHandlingMiddleware(apiOptions)]).filter(Boolean);
}

var store = {
  getCommonMiddlewares: getCommonMiddlewares,
  defaultOptions: defaultOptions
};

export { APP_ONLINE, defaultOptions, store, utils };