@drieam/common/lib/index.js

Default Drieam api wrapper

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var React = require('react');
var ReactDOM = require('react-dom');
var get = require('lodash/get');
var camelCase = require('lodash/camelCase');
require('lodash/isNil');
var ResizeObserver = require('resize-observer-polyfill');
var api = require('@drieam/api');
var Notification = require('antd/lib/notification');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
var camelCase__default = /*#__PURE__*/_interopDefaultLegacy(camelCase);
var ResizeObserver__default = /*#__PURE__*/_interopDefaultLegacy(ResizeObserver);
var Notification__default = /*#__PURE__*/_interopDefaultLegacy(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__default['default'](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__default['default'].render( /*#__PURE__*/React__default['default'].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__default['default'](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({}, api.defaultOptions), {
  // 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__default['default'];
var ENTITY_ACTIONS = [api.SAVE_ENTITY_SUCCESS, api.SAVE_ENTITY_FAILED, api.SAVE_LIST_SUCCESS, api.DELETE_ENTITY_SUCCESS, api.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__default['default'](parentOptions, "toasts.offline")), {
              key: "offline"
            }));
          }
        } else if (ENTITY_ACTIONS.includes(action.type)) {
          var toasts = opts.toasts;

          switch (action.type) {
            case api.SAVE_ENTITY_SUCCESS:
            case api.SAVE_LIST_SUCCESS:
              if (!get__default['default'](toasts, "save")) {
                break;
              }

              notificationApi.success(toasts.save);
              break;

            case api.DELETE_ENTITY_SUCCESS:
              if (!get__default['default'](toasts, "delete")) {
                break;
              }

              notificationApi.success(toasts.delete);
              break;

            case api.DELETE_ENTITY_FAILED:
            case api.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(api.apiMiddlewares(apiRoutes, apiOptions), [apiOptions.withErrorHandler && errorHandlingMiddleware(apiOptions)]).filter(Boolean);
}

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

exports.APP_ONLINE = APP_ONLINE;
exports.defaultOptions = defaultOptions;
exports.store = store;
exports.utils = utils;