@lyra/form-builder/lib/lyra/inputs/client-adapters/assets.js

Lyra form builder

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.uploadFileAsset = exports.uploadImageAsset = undefined;
exports.materializeReference = materializeReference;

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

var _client2 = _interopRequireDefault(_client);

var _preview = require('part:@lyra/base/preview');

var _operators = require('rxjs/operators');

var _rxjs = require('rxjs');

var _withMaxConcurrency = require('../../utils/withMaxConcurrency');

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

const MAX_CONCURRENT_UPLOADS = 4;

function uploadLyraAsset(assetType, file, options = {}) {
  const extract = options.metadata;
  return (0, _rxjs.from)(hashFile(file)).pipe((0, _operators.catchError)(error =>
  // ignore if hashing fails for some reason
  (0, _rxjs.of)(null)), (0, _operators.mergeMap)(hash => hash ? fetchExisting(`lyra.${assetType}Asset`, hash) : (0, _rxjs.of)(null)), (0, _operators.mergeMap)(existing => {
    if (existing) {
      return (0, _rxjs.of)({
        // complete with the existing asset document
        type: 'complete',
        id: existing._id,
        asset: existing
      });
    }
    return _client2.default.observable.assets.upload(assetType, file, { extract }).pipe((0, _operators.map)(event => event.type === 'response' ? {
      // rewrite to a 'complete' event
      type: 'complete',
      id: event.body.document._id,
      asset: event.body.document
    } : event));
  }));
}

const uploadAsset = (0, _withMaxConcurrency.withMaxConcurrency)(uploadLyraAsset, MAX_CONCURRENT_UPLOADS);

const uploadImageAsset = exports.uploadImageAsset = (file, options) => uploadAsset('image', file, options);
const uploadFileAsset = exports.uploadFileAsset = (file, options) => uploadAsset('file', file, options);

function materializeReference(id) {
  return (0, _preview.observePaths)(id, ['originalFilename', 'url', 'metadata']);
}

function fetchExisting(type, hash) {
  return _client2.default.observable.fetch('*[_type == $documentType && sha1hash == $hash][0]', {
    documentType: type,
    hash
  });
}

function readFile(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = () => resolve(reader.result);
    reader.onerror = reject;
    reader.readAsArrayBuffer(file);
  });
}

function hashFile(file) {
  if (!window.crypto || !window.crypto.subtle || !window.FileReader) {
    return Promise.resolve(null);
  }
  return readFile(file).then(arrayBuffer => crypto.subtle.digest('SHA-1', arrayBuffer)).then(hexFromBuffer);
}

function hexFromBuffer(buffer) {
  return Array.prototype.map.call(new Uint8Array(buffer), x => `00${x.toString(16)}`.slice(-2)).join('');
}