lacona-osx/lib/app.js

Lacona Extensions for OSX, tied into the global-context hosted API

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.App = exports.ApplicationSource = undefined;

let getSpecificApps = (() => {
  var _ref = _asyncToGenerator(function* (applications) {
    const infoPromises = _lodash2.default.map(applications, function (name) {
      return (0, _laconaApi.fetchApplication)({ name });
    });
    const info = yield Promise.all(infoPromises);
    return _lodash2.default.filter(info);
  });

  return function getSpecificApps(_x) {
    return _ref.apply(this, arguments);
  };
})();

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _laconaPhrases = require('lacona-phrases');

var _elliptical = require('elliptical');

var _map = require('rxjs/operator/map');

var _mergeMap = require('rxjs/operator/mergeMap');

var _laconaApi = require('lacona-api');

var _utils = require('./utils');

var _path = require('path');

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } /** @jsx createElement */


class AppObject {
  constructor({ name, path }) {
    this.name = name;
    this.type = 'application';
    this.path = path;
    this[_elliptical.unique] = path;
  }

  open() {
    (0, _laconaApi.openFile)({ path: this.path }, () => {});
  }

  openURL(url) {
    (0, _laconaApi.openURLInApplication)({ url, applicationPath: this.path });
  }

  openFile(path) {
    (0, _laconaApi.openFileInApplication)({ path, applicationPath: this.path });
  }
}

const ApplicationSource = exports.ApplicationSource = {
  fetch({ props }) {
    var _context;

    return (_context = (_context = (_context = (0, _laconaApi.watchApplications)({
      directories: props.applicationSearchDirectories
    }), _map.map).call(_context, data => {
      // Add in the alternativeNames, but remove .app and case-insensitive uniquify
      const newData = _lodash2.default.chain(data).filter().filter('name').filter('bundleId').filter('path').flatMap(item => {
        const allNames = _lodash2.default.chain([item.name]).concat(item.alternativeNames || []).map(name => _lodash2.default.endsWith(_lodash2.default.toLower(name), '.app') ? name.slice(0, -4) : name).uniqBy(_lodash2.default.toLower).value();

        return _lodash2.default.map(allNames, name => ({
          bundleId: item.bundleId,
          name,
          path: item.path
        }));
      }).value();

      return newData;
    }), _mergeMap.mergeMap).call(_context, (() => {
      var _ref2 = _asyncToGenerator(function* (data) {
        const specificApps = yield getSpecificApps(props.namedApplications);
        return data.concat(specificApps);
      });

      return function (_x2) {
        return _ref2.apply(this, arguments);
      };
    })()), _map.map).call(_context, data => {
      return _lodash2.default.map(data, item => new AppObject(item));
    });
  }
};

const App = exports.App = {
  extends: [_laconaPhrases.Application],

  describe({ observe, props, config }) {
    const data = observe((0, _elliptical.createElement)(ApplicationSource, {
      namedApplications: config.namedApplications,
      applicationSearchDirectories: config.applicationSearchDirectories }));
    const apps = _lodash2.default.map(data, app => ({
      text: app.name,
      value: app,
      annotation: { type: 'icon', value: app.path },
      qualifiers: (0, _utils.subPaths)((0, _path.dirname)(app.path))
    }));

    return (0, _elliptical.createElement)(
      'placeholder',
      { argument: 'application', suppressEmpty: props.suppressEmpty },
      (0, _elliptical.createElement)('list', { strategy: 'fuzzy', items: apps, limit: 10, unique: true })
    );
  }
};