npmc/node_modules/libpickupdates/dist/index.js

a package manager for JavaScript

"use strict";

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

var _ink = require("ink");

var _inkSpinner = _interopRequireDefault(require("ink-spinner"));

var _react = _interopRequireWildcard(require("react"));

var _updatePicker = _interopRequireDefault(require("./update-picker"));

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

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

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

const STATES = {
  init: 'init',
  fetchOutdated: 'fetch-outdated',
  pickUpdates: 'pick-updates',
  updating: 'updating',
  updated: 'updated',
  alreadyUpToDate: 'already-up-to-date'
};

function PickUpdatesComponent({
  stdin,
  onDone,
  unicode,
  getOutdated,
  installUpdates
}) {
  const _useState = (0, _react.useState)(STATES.init),
        _useState2 = _slicedToArray(_useState, 2),
        state = _useState2[0],
        setState = _useState2[1];

  const _useState3 = (0, _react.useState)(null),
        _useState4 = _slicedToArray(_useState3, 2),
        outdated = _useState4[0],
        setOutdated = _useState4[1];

  const _useState5 = (0, _react.useState)([]),
        _useState6 = _slicedToArray(_useState5, 2),
        updated = _useState6[0],
        setUpdated = _useState6[1];

  function updateDeps(names) {
    setState(STATES.updating);
    installUpdates(names).then(() => {
      setState(STATES.updated);
    });
    setUpdated(names);
  }

  if (state === STATES.init) {
    getOutdated().then(setOutdated);
    setState(STATES.fetchOutdated);
  } else if (state === STATES.fetchOutdated) {
    if (outdated && Object.keys(outdated).length) {
      setState(STATES.pickUpdates);
    } else if (outdated) {
      setState(STATES.alreadyUpToDate);
    }

    return _react.default.createElement(_ink.Text, null, _react.default.createElement(_ink.Color, {
      green: true
    }, _react.default.createElement(_inkSpinner.default, null)), " checking dependency updates");
  } else if (state === STATES.pickUpdates) {
    return _react.default.createElement(_updatePicker.default, {
      outdated: outdated,
      stdin: stdin,
      unicode: unicode,
      onSubmit: updateDeps
    });
  } else if (state === STATES.alreadyUpToDate) {
    setImmediate(onDone);
    return _react.default.createElement(_ink.Text, null, "already up to date!");
  } else if (state === STATES.updating) {
    return _react.default.createElement(_ink.Text, null, "installing updated deps");
  } else if (state === STATES.updated) {
    setImmediate(onDone);
    return _react.default.createElement(_ink.Text, null, '');
  } else {
    return _react.default.createElement(_ink.Text, null, '');
  }
}