@lyra/base/lib/components/VersionChecker.js

Lyra plugin containing the base components and roles for a Lyra configuration

'use strict';

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

var _omit2 = require('lodash/omit');

var _omit3 = _interopRequireDefault(_omit2);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _semverCompare = require('semver-compare');

var _semverCompare2 = _interopRequireDefault(_semverCompare);

var _lyraVersions = require('lyra:versions');

var _lyraVersions2 = _interopRequireDefault(_lyraVersions);

var _fullscreen = require('part:@lyra/components/dialogs/fullscreen?');

var _fullscreen2 = _interopRequireDefault(_fullscreen);

var _client = require('part:@lyra/base/client');

var _client2 = _interopRequireDefault(_client);

var _FullscreenError = require('./FullscreenError');

var _FullscreenError2 = _interopRequireDefault(_FullscreenError);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const fakeOutdatedModule = false;
const fakeOutdatedModuleSeverity = 'high';
let applySeverity = inp => inp;

if (fakeOutdatedModule) {
  _lyraVersions2.default['@lyra/base'] = '0.118.0';
  applySeverity = inp => {
    const mod = inp && inp.outdated.find(item => item.name === '@lyra/base') || {};
    mod.severity = fakeOutdatedModuleSeverity;
    return inp;
  };
}

const onIdle = typeof window.requestIdleCallback === 'function' ? window.requestIdleCallback : cb => setTimeout(cb, 0);

// eslint-disable-next-line id-length
const buildQueryString = () => ({
  m: Object.keys(_lyraVersions2.default).map(pkg => `${pkg}@${_lyraVersions2.default[pkg]}`)
});
const hashQuery = items => items.join(',').replace(/@?lyra[/-]/g, '');
const storage = typeof sessionStorage === 'undefined' ? {} : sessionStorage;

const onVersionCheckError = err => {
  // eslint-disable-next-line no-console
  console.warn('Module versions check failed. Dependencies *might* be out of date.', err);
};

const breakify = lines => {
  const nodes = [];
  for (let i = 0; i < lines.length; i++) {
    nodes.push(lines[i]);
    if (i !== lines.length - 1) {
      nodes.push(_react2.default.createElement('br', { key: i }));
    }
  }
  return nodes;
};

const paragraphify = text => {
  return text.split('\n\n').map((para, i) => {
    const lines = para.split('\n');
    // eslint-disable-next-line react/no-array-index-key
    return _react2.default.createElement(
      'p',
      { key: i },
      breakify(lines)
    );
  });
};

const getLatestInstalled = () => {
  const versionNums = Object.keys(_lyraVersions2.default).map(pkg => _lyraVersions2.default[pkg]);
  const sorted = versionNums.sort(_semverCompare2.default);
  return sorted[sorted.length - 1];
};

const checkVersions = (options = {}) => {
  const getOutdated = options.getOutdated;

  const query = buildQueryString();
  const hash = hashQuery(query.m);
  const local = storage.versionCheck && storage.versionCheck.indexOf(hash) === 0 && storage.versionCheck.slice(hash.length + 1);

  if (!getOutdated && local) {
    return Promise.resolve({ result: JSON.parse(local) });
  }

  return _client2.default.request({
    uri: '/versions',
    query: buildQueryString(),
    json: true
  }).then(result => ({
    hash,
    result: applySeverity(result)
  }));
};

class VersionChecker extends _react.PureComponent {
  constructor(...args) {
    super(...args);
    this.state = {};
    this.onResponse = this.onResponse.bind(this);
    this.handleClose = this.handleClose.bind(this);
  }

  onResponse(res) {
    // Don't include outdated modules in the stored result
    const result = (0, _omit3.default)(res.result, ['outdated']);
    if (result.hash && storage) {
      storage.versionCheck = [res.hash, JSON.stringify(result)].join('|');
    }

    // If we have unsupported modules, we want to show a dialog
    if (!result.isSupported) {
      this.setState({ result });
    }

    if (__DEV__ && res.result && res.result.outdated) {
      const modules = res.result.outdated.map(mod => mod.name).join('\n  - ');
      const instructions = 'Run `lyra upgrade` to update them';
      // eslint-disable-next-line no-console
      console.warn(`The following modules are outdated:\n  - ${modules}\n\n${instructions}`);
    }
  }

  handleClose() {
    this.setState({ result: null });
  }

  componentDidMount() {
    onIdle(() => {
      checkVersions().then(this.onResponse).catch(onVersionCheckError);
    });
  }

  render() {
    const result = this.state.result;
    if (!result || result.isSupported || result.isSupported === undefined) {
      return null;
    }

    const Dialog = _fullscreen2.default || _FullscreenError2.default;
    const title = 'Unsupported module versions';

    return _react2.default.createElement(
      Dialog,
      {
        centered: true,
        isOpen: true,
        color: 'danger',
        title: title,
        onClose: this.handleClose
      },
      paragraphify(result.message || ''),
      result.helpUrl && _react2.default.createElement(
        'p',
        null,
        'For more information, please read',
        ' ',
        _react2.default.createElement(
          'a',
          { href: result.helpUrl },
          result.helpUrl
        )
      )
    );
  }
}

VersionChecker.checkVersions = checkVersions;
VersionChecker.getLatestInstalled = getLatestInstalled;

exports.default = VersionChecker;