/**
* @license uploadcare-widget v3.21.0
*
* Copyright (c) 2022 Uploadcare, Inc.
*
* This source code is licensed under the BSD 2-Clause License
* found in the LICENSE file in the root directory of this source tree.
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery')) :
typeof define === 'function' && define.amd ? define(['jquery'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.uploadcare = factory(global.$));
})(this, (function ($) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var $__default = /*#__PURE__*/_interopDefaultLegacy($);
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
enumerableOnly && (symbols = symbols.filter(function (sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
})), keys.push.apply(keys, symbols);
}
return keys;
}
function _objectSpread2(target) {
for (var i = 1; i < arguments.length; i++) {
var source = null != arguments[i] ? arguments[i] : {};
i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
_defineProperty(target, key, source[key]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function _typeof(obj) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
return typeof obj;
} : function (obj) {
return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
}, _typeof(obj);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
function _defineProperty(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
Object.defineProperty(subClass, "prototype", {
writable: false
});
if (superClass) _setPrototypeOf(subClass, superClass);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
return true;
} catch (e) {
return false;
}
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _possibleConstructorReturn(self, call) {
if (call && (typeof call === "object" || typeof call === "function")) {
return call;
} else if (call !== void 0) {
throw new TypeError("Derived constructors may only return object or undefined");
}
return _assertThisInitialized(self);
}
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = _getPrototypeOf(Derived),
result;
if (hasNativeReflectConstruct) {
var NewTarget = _getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possibleConstructorReturn(this, result);
};
}
function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = _getPrototypeOf(object);
if (object === null) break;
}
return object;
}
function _get() {
if (typeof Reflect !== "undefined" && Reflect.get) {
_get = Reflect.get;
} else {
_get = function _get(target, property, receiver) {
var base = _superPropBase(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(arguments.length < 3 ? target : receiver);
}
return desc.value;
};
}
return _get.apply(this, arguments);
}
function _slicedToArray(arr, i) {
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _iterableToArrayLimit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
if (_i == null) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for (_i = _i.call(arr); !(_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 _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _createForOfIteratorHelper(o, allowArrayLike) {
var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
if (!it) {
if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
if (it) o = it;
var i = 0;
var F = function () {};
return {
s: F,
n: function () {
if (i >= o.length) return {
done: true
};
return {
done: false,
value: o[i++]
};
},
e: function (e) {
throw e;
},
f: F
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var normalCompletion = true,
didErr = false,
err;
return {
s: function () {
it = it.call(o);
},
n: function () {
var step = it.next();
normalCompletion = step.done;
return step;
},
e: function (e) {
didErr = true;
err = e;
},
f: function () {
try {
if (!normalCompletion && it.return != null) it.return();
} finally {
if (didErr) throw err;
}
}
};
}
// utils
var log = function log() {
var ref;
try {
var _ref;
return (ref = window.console) != null ? typeof ref.log === 'function' ? (_ref = ref).log.apply(_ref, arguments) : undefined : undefined;
} catch (error) {}
};
var debug = function debug() {
var ref;
if ((ref = window.console) != null ? ref.debug : undefined) {
try {
var _window$console;
return (_window$console = window.console).debug.apply(_window$console, arguments);
} catch (error) {}
} else {
return log.apply(void 0, ['Debug:'].concat(Array.prototype.slice.call(arguments)));
}
};
var warn = function warn() {
var ref;
if ((ref = window.console) != null ? ref.warn : undefined) {
try {
var _window$console2;
return (_window$console2 = window.console).warn.apply(_window$console2, arguments);
} catch (error) {}
} else {
return log.apply(void 0, ['Warning:'].concat(Array.prototype.slice.call(arguments)));
}
};
var messages = {};
var warnOnce = function warnOnce(msg) {
if (messages[msg] == null) {
messages[msg] = true;
return warn(msg);
}
};
var isWindowDefined = function isWindowDefined() {
return (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object';
};
var isWindowDefined$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
isWindowDefined: isWindowDefined
});
var REQUEST_WAS_THROTTLED_CODE = 'RequestThrottledError';
var DEFAULT_THROTTLED_TIMEOUT = 15000;
/**
* @typedef {object} RetryState
* @property {number} [attempt]
* @property {number} [timeoutId]
* @property {JQuery.jqXHR} [jqXHR]
*/
/**
* @typedef {object} RetryConfig
* @property {number} baseTimeout
* @property {number} attempts
* @property {number} throttledAttempts
* @property {number} factor
* @property {boolean} debugUploads
* @property {Function} [onAttemptFail]
*/
/**
* @param {JQuery.jqXHR} jqXHR
* @param {RetryConfig} config
* @param {RetryState} state
*/
function getRetrySettings(jqXHR, config, state) {
var _jqXHR$responseJSON, _jqXHR$responseJSON$e;
var isThrottled = (jqXHR === null || jqXHR === void 0 ? void 0 : (_jqXHR$responseJSON = jqXHR.responseJSON) === null || _jqXHR$responseJSON === void 0 ? void 0 : (_jqXHR$responseJSON$e = _jqXHR$responseJSON.error) === null || _jqXHR$responseJSON$e === void 0 ? void 0 : _jqXHR$responseJSON$e.error_code) === REQUEST_WAS_THROTTLED_CODE;
if (isThrottled && state.attempt < config.throttledAttempts) {
var retryAfter = Number.parseFloat(jqXHR.getResponseHeader('retry-after'));
return {
shouldRetry: true,
retryTimeout: Number.isFinite(retryAfter) ? Math.ceil(retryAfter * 1000) : DEFAULT_THROTTLED_TIMEOUT
};
}
var isRequestFailed = ['error', 'timeout'].indexOf(jqXHR.statusText) !== -1;
if (isRequestFailed && state.attempt < config.attempts) {
var retryTimeout = Math.round(config.baseTimeout * Math.pow(config.factor, state.attempt));
return {
shouldRetry: true,
retryTimeout: retryTimeout
};
}
return {
shouldRetry: false
};
}
/**
*
* @param {JQuery.jqXHR} jqXHR
* @param {JQuery.AjaxSettings} ajaxSettings
* @param {RetryConfig} config
* @param {RetryState} state
* @returns
*/
function createPipeFilter(jqXHR, ajaxSettings, config, state) {
return function () {
var df = $__default["default"].Deferred();
function nextRequest() {
state.jqXHR = $__default["default"].ajax(ajaxSettings).retry(config, _objectSpread2(_objectSpread2({}, state), {}, {
attempt: state.attempt + 1
})).done(df.resolve).fail(df.reject);
}
var _getRetrySettings = getRetrySettings(jqXHR, config, state),
shouldRetry = _getRetrySettings.shouldRetry,
retryTimeout = _getRetrySettings.retryTimeout;
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
if (shouldRetry) {
var _config$onAttemptFail;
(_config$onAttemptFail = config.onAttemptFail) === null || _config$onAttemptFail === void 0 ? void 0 : _config$onAttemptFail.call(config, {
attempt: state.attempt
});
if (config.debugUploads) {
log("Attempt failed. Retry #".concat(state.attempt + 1, " in ").concat(retryTimeout, "ms"), jqXHR);
}
state.timeoutId = setTimeout(nextRequest, retryTimeout);
} else if (jqXHR.state() === 'resolved') {
df.resolveWith(jqXHR, args);
} else {
df.rejectWith(jqXHR, args);
}
return df;
};
}
/**
*
* @param {JQuery.jqXHR} jqXHR
* @param {JQuery.AjaxSettings} ajaxSettings
* @param {RetryConfig} retryConfig
* @param {RetryState} retryState
* @returns {JQuery.PromiseBase}
*/
function ajaxRetry(jqXHR, ajaxSettings, retryConfig, retryState) {
var missedOption = ['baseTimeout', 'attempts', 'factor'].find(function (key) {
return typeof retryConfig[key] === 'undefined';
});
if (missedOption) {
warn("Option key \"".concat(missedOption, "\" is missed in the retry config."));
return jqXHR;
}
retryState = {
attempt: retryState.attempt || 0,
timeoutId: null,
jqXHR: null
};
retryConfig = _objectSpread2({
baseTimeout: null,
attempts: null,
factor: null,
onAttemptFail: null,
debugUploads: false
}, retryConfig);
var pipeFilter = createPipeFilter(jqXHR, ajaxSettings, retryConfig, retryState);
var df = jqXHR.then(pipeFilter, pipeFilter);
df.abort = function () {
var _retryState$jqXHR;
clearTimeout(retryState.timeoutId);
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
jqXHR.abort.apply(jqXHR, args);
(_retryState$jqXHR = retryState.jqXHR) === null || _retryState$jqXHR === void 0 ? void 0 : _retryState$jqXHR.abort.apply(_retryState$jqXHR, args);
};
return df;
}
isWindowDefined() && function () {
$__default["default"].ajaxPrefilter(function (ajaxSettings, _, jqXHR) {
jqXHR.retry = function (retryConfig) {
var retryState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
return ajaxRetry(jqXHR, ajaxSettings, retryConfig, retryState);
};
});
}();
if (isWindowDefined() && window.XDomainRequest) {
$__default["default"].ajaxTransport(function (s) {
if (s.crossDomain && s.async) {
if (s.timeout) {
s.xdrTimeout = s.timeout;
delete s.timeout;
}
var xdr;
return {
send: function send(_, complete) {
function callback(status, statusText, responses, responseHeaders) {
xdr.onload = xdr.onerror = xdr.ontimeout = function () {};
xdr = undefined;
complete(status, statusText, responses, responseHeaders);
}
xdr = new XDomainRequest();
xdr.onload = function () {
callback(200, "OK", {
text: xdr.responseText
}, "Content-Type: " + xdr.contentType);
};
xdr.onerror = function () {
callback(404, "Not Found");
};
xdr.onprogress = function () {};
xdr.ontimeout = function () {
callback(0, "timeout");
};
xdr.timeout = s.xdrTimeout || Number.MAX_VALUE;
xdr.open(s.type, s.url.replace(/^https?:/, ''));
xdr.send(s.hasContent && s.data || null);
},
abort: function abort() {
if (xdr) {
xdr.onerror = function () {};
xdr.abort();
}
}
};
}
});
}
var version = "3.21.0";
var fileAPI = isWindowDefined() && !!(window.File && window.FileList && window.FileReader);
var sendFileAPI = isWindowDefined() && !!(window.FormData && fileAPI); // https://github.com/Modernizr/Modernizr/blob/master/feature-detects/draganddrop.js
var dragAndDrop = isWindowDefined() && function () {
var el;
el = document.createElement('div');
return 'draggable' in el || 'ondragstart' in el && 'ondrop' in el;
}(); // https://github.com/Modernizr/Modernizr/blob/master/feature-detects/canvas.js
var canvas = isWindowDefined() && function () {
var el;
el = document.createElement('canvas');
return !!(el.getContext && el.getContext('2d'));
}();
var fileDragAndDrop = fileAPI && dragAndDrop;
var iOSVersion = null; // TODO: don't access to navigator in module scope (NODE don't have navigator)
var ios = isWindowDefined() && /^[^(]+\(iP(?:hone|od|ad);\s*(.+?)\)/.exec(navigator.userAgent);
if (ios) {
var ver = /OS (\d*)_(\d*)/.exec(ios[1]);
if (ver) {
iOSVersion = +ver[1] + ver[2] / 10;
}
} // There is no a guaranteed way to detect iPadOs, cause it mimics the desktop safari.
// So we're checkin for multitouch support and `navigator.platform` value.
// Since no desktop macs with multitouch exists, this check will work. For now at least.
// Workaround source: https://stackoverflow.com/questions/57776001/how-to-detect-ipad-pro-as-ipad-using-javascript
var isIpadOs = isWindowDefined() && navigator.maxTouchPoints && navigator.maxTouchPoints > 2 && /MacIntel/.test(navigator.platform);
var Blob = false;
try {
if (isWindowDefined() && new window.Blob()) {
Blob = window.Blob;
}
} catch (error) {}
var url = isWindowDefined() && (window.URL || window.webkitURL || false);
var URL = url && url.createObjectURL && url;
var FileReader = isWindowDefined() && (window.FileReader != null ? window.FileReader.prototype.readAsArrayBuffer : undefined) && window.FileReader;
var indexOf$2 = [].indexOf; // utils
var unique = function unique(arr) {
var item, j, len, result;
result = [];
for (j = 0, len = arr.length; j < len; j++) {
item = arr[j];
if (indexOf$2.call(result, item) < 0) {
result.push(item);
}
}
return result;
};
var defer = function defer(fn) {
return setTimeout(fn, 0);
};
var gcd = function gcd(a, b) {
var c;
while (b) {
c = a % b;
a = b;
b = c;
}
return a;
};
var once = function once(fn) {
var called, result;
called = false;
result = null;
return function () {
if (!called) {
result = fn.apply(this, arguments);
called = true;
}
return result;
};
};
var wrapToPromise = function wrapToPromise(value) {
return $__default["default"].Deferred().resolve(value).promise();
}; // same as promise.then(), but if filter returns promise
// it will be just passed forward without any special behavior
var then = function then(pr, doneFilter, failFilter, progressFilter) {
var compose, df;
df = $__default["default"].Deferred();
compose = function compose(fn1, fn2) {
if (fn1 && fn2) {
return function () {
return fn2.call(this, fn1.apply(this, arguments));
};
} else {
return fn1 || fn2;
}
};
pr.then(compose(doneFilter, df.resolve), compose(failFilter, df.reject), compose(progressFilter, df.notify));
return df.promise();
}; // Build copy of source with only specified methods.
// Handles chaining correctly.
var bindAll = function bindAll(source, methods) {
var target;
target = {};
$__default["default"].each(methods, function (i, method) {
var fn = source[method];
if ($__default["default"].isFunction(fn)) {
target[method] = function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var result = fn.apply(source, args); // Fix chaining
if (result === source) {
return target;
} else {
return result;
}
};
} else {
target[method] = fn;
}
});
return target;
};
var upperCase = function upperCase(s) {
return s.replace(/([A-Z])/g, '_$1').toUpperCase();
};
var publicCallbacks = function publicCallbacks(callbacks) {
var result;
result = callbacks.add;
result.add = callbacks.add;
result.remove = callbacks.remove;
return result;
};
var uuid = function uuid() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = Math.random() * 16 | 0;
var v = c === 'x' ? r : r & 3 | 8;
return v.toString(16);
});
}; // splitUrlRegex("url") => ["url", "scheme", "host", "path", "query", "fragment"]
var splitUrlRegex = /^(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)\??([^#]*)#?(.*)$/;
var uuidRegex = /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i;
var groupIdRegex = new RegExp("".concat(uuidRegex.source, "~[0-9]+"), 'i');
var cdnUrlRegex = new RegExp("^/?(".concat(uuidRegex.source, ")(?:/(-/(?:[^/]+/)+)?([^/]*))?$"), 'i');
var splitCdnUrl = function splitCdnUrl(url) {
return cdnUrlRegex.exec(splitUrlRegex.exec(url)[3]);
};
var escapeRegExp = function escapeRegExp(str) {
return str.replace(/[\\-\\[]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
};
var globRegexp = function globRegexp(str) {
var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'i';
var parts;
parts = $__default["default"].map(str.split('*'), escapeRegExp);
return new RegExp('^' + parts.join('.+') + '$', flags);
};
var normalizeUrl = function normalizeUrl(url) {
var scheme; // google.com/ → google.com
// /google.com/ → /google.com
// //google.com/ → http://google.com
// http://google.com/ → http://google.com
scheme = document.location.protocol;
if (scheme !== 'http:') {
scheme = 'https:';
}
return url.replace(/^\/\//, scheme + '//').replace(/\/+$/, '');
};
var fitText = function fitText(text, max) {
if (text.length > max) {
var head = Math.ceil((max - 3) / 2);
var tail = Math.floor((max - 3) / 2);
return text.slice(0, head) + '...' + text.slice(-tail);
} else {
return text;
}
};
var fitSizeInCdnLimit = function fitSizeInCdnLimit(objSize) {
return fitSize(objSize, [2048, 2048]);
};
var fitSize = function fitSize(objSize, boxSize, upscale) {
var heightRation, widthRatio;
if (objSize[0] > boxSize[0] || objSize[1] > boxSize[1] || upscale) {
widthRatio = boxSize[0] / objSize[0];
heightRation = boxSize[1] / objSize[1];
if (!boxSize[0] || boxSize[1] && widthRatio > heightRation) {
return [Math.round(heightRation * objSize[0]), boxSize[1]];
} else {
return [boxSize[0], Math.round(widthRatio * objSize[1])];
}
} else {
return objSize.slice();
}
};
var applyCropCoordsToInfo = function applyCropCoordsToInfo(info, crop, size, coords) {
var downscale, h, modifiers, prefered, upscale, w, wholeImage;
w = coords.width;
h = coords.height;
prefered = crop.preferedSize;
modifiers = '';
wholeImage = w === size[0] && h === size[1];
if (!wholeImage) {
modifiers += "-/crop/".concat(w, "x").concat(h, "/").concat(coords.left, ",").concat(coords.top, "/");
}
downscale = crop.downscale && (w > prefered[0] || h > prefered[1]);
upscale = crop.upscale && (w < prefered[0] || h < prefered[1]);
if (downscale || upscale) {
var _prefered = prefered;
var _prefered2 = _slicedToArray(_prefered, 2);
coords.sw = _prefered2[0];
coords.sh = _prefered2[1];
modifiers += "-/resize/".concat(prefered.join('x'), "/");
} else if (!wholeImage) {
modifiers += '-/preview/';
}
info = $__default["default"].extend({}, info);
info.cdnUrlModifiers = modifiers;
info.cdnUrl = "".concat(info.originalUrl).concat(modifiers || '');
info.crop = coords;
return info;
};
var imagesOnlyAcceptTypes = ['image/*', 'image/heif', 'image/heif-sequence', 'image/heic', 'image/heic-sequence', 'image/avif', 'image/avif-sequence', '.heif', '.heifs', '.heic', '.heics', '.avif', '.avifs'].join(',');
var fileInput = function fileInput(container, settings, fn) {
var accept, input, _run;
input = null;
accept = settings.inputAcceptTypes;
if (accept === '') {
accept = settings.imagesOnly ? imagesOnlyAcceptTypes : null;
}
(_run = function run() {
input = (settings.multiple ? $__default["default"]('') : $__default["default"]('')).attr('accept', accept).css({
position: 'absolute',
top: 0,
opacity: 0,
margin: 0,
padding: 0,
width: 'auto',
height: 'auto',
cursor: container.css('cursor')
}).on('change', function () {
fn(this);
$__default["default"](this).hide();
return _run();
});
return container.append(input);
})();
return container.css({
position: 'relative',
overflow: 'hidden' // to make it posible to set `cursor:pointer` on button
// http://stackoverflow.com/a/9182787/478603
}).mousemove(function (e) {
var left, top, width;
var _$$offset = $__default["default"](this).offset();
left = _$$offset.left;
top = _$$offset.top;
width = input.width();
return input.css({
left: e.pageX - left - width + 10,
top: e.pageY - top - 10
});
});
};
var fileSelectDialog = function fileSelectDialog(container, settings, fn) {
var attributes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
var accept;
accept = settings.inputAcceptTypes;
if (accept === '') {
accept = settings.imagesOnly ? imagesOnlyAcceptTypes : null;
}
return $__default["default"](settings.multiple ? '' : '').attr('accept', accept).attr(attributes).css({
position: 'fixed',
bottom: 0,
opacity: 0
}).on('change', function () {
fn(this);
return $__default["default"](this).remove();
}).appendTo(container).focus().click().hide();
};
var fileSizeLabels = 'B KB MB GB TB PB EB ZB YB'.split(' ');
var readableFileSize = function readableFileSize(value) {
var onNaN = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
var postfix = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
var digits, fixedTo, i, threshold;
value = parseInt(value, 10);
if (isNaN(value)) {
return onNaN;
}
digits = 2;
i = 0;
threshold = 1000 - 5 * Math.pow(10, 2 - Math.max(digits, 3));
while (value > threshold && i < fileSizeLabels.length - 1) {
i++;
value /= 1024;
}
value += 0.000000000000001;
fixedTo = Math.max(0, digits - Math.floor(value).toFixed(0).length); // fixed → number → string, to trim trailing zeroes
value = Number(value.toFixed(fixedTo)); // eslint-disable-next-line no-irregular-whitespace
return "".concat(prefix).concat(value, "\xA0").concat(fileSizeLabels[i]).concat(postfix);
};
var ajaxDefaults = {
dataType: 'json',
crossDomain: true,
cache: false
};
var jsonp = function jsonp(url, type, data) {
var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
var jqXHR = $__default["default"].ajax($__default["default"].extend({
url: url,
type: type,
data: data
}, options, ajaxDefaults)).retry(options.retryConfig).fail(function (_, textStatus, errorThrown) {
var text = "".concat(textStatus, " (").concat(errorThrown, ")");
warn("JSONP unexpected error: ".concat(text, " while loading ").concat(url));
});
var df = jqXHR.then(function (data) {
if (data.error) {
var message, code;
if (typeof data.error === 'string') {
// /from_url/state/ case
message = data.error;
code = data.error_code;
} else {
// other cases (direct/multipart/group)
message = data.error.content;
code = data.error.error_code;
}
return $__default["default"].Deferred().reject({
message: message,
code: code
});
}
return data;
});
df.abort = jqXHR.abort.bind(jqXHR);
return df;
};
var canvasToBlob = function canvasToBlob(canvas, type, quality, callback) {
var arr, binStr, dataURL, i, j, ref;
if (window.HTMLCanvasElement.prototype.toBlob) {
return canvas.toBlob(callback, type, quality);
}
dataURL = canvas.toDataURL(type, quality);
dataURL = dataURL.split(',');
binStr = window.atob(dataURL[1]);
arr = new Uint8Array(binStr.length);
for (i = j = 0, ref = binStr.length; j < ref; i = j += 1) {
arr[i] = binStr.charCodeAt(i);
}
return callback(new window.Blob([arr], {
type: /:(.+\/.+);/.exec(dataURL[0])[1]
}));
};
var taskRunner = function taskRunner(capacity) {
var queue, _release, run, running;
running = 0;
queue = [];
_release = function release() {
var task;
if (queue.length) {
task = queue.shift();
return defer(function () {
return task(_release);
});
} else {
running -= 1;
return running;
}
};
run = function run(task) {
if (!capacity || running < capacity) {
running += 1;
return defer(function () {
return task(_release);
});
} else {
return queue.push(task);
}
};
return run;
}; // This is work around bug in jquery https://github.com/jquery/jquery/issues/2013
// action, add listener, callbacks,
// ... .then handlers, argument index, [final state]
var pipeTuples = [['notify', 'progress', 2], ['resolve', 'done', 0], ['reject', 'fail', 1]];
var fixedPipe = function fixedPipe(promise) {
for (var _len2 = arguments.length, fns = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
fns[_key2 - 1] = arguments[_key2];
}
return $__default["default"].Deferred(function (newDefer) {
return $__default["default"].each(pipeTuples, function (i, tuple) {
var fn; // Map tuples (progress, done, fail) to arguments (done, fail, progress)
fn = $__default["default"].isFunction(fns[tuple[2]]) && fns[tuple[2]];
return promise[tuple[1]](function () {
var returned;
returned = fn && fn.apply(this, arguments);
if (returned && $__default["default"].isFunction(returned.promise)) {
return returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
} else {
return newDefer[tuple[0] + 'With'](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments);
}
});
});
}).promise();
};
var getMetadataObject = function getMetadataObject(settings) {
var metadata;
if (settings.metadataCallback) {
metadata = settings.metadataCallback() || {};
} else {
metadata = settings.metadata || {};
}
metadata = _objectSpread2({}, metadata);
$__default["default"].each(metadata, function (key, value) {
metadata[key] = String(value);
});
return metadata;
};
var isObject = function isObject(input) {
return Object.prototype.toString.call(input) === '[object Object]';
};
var TestPixel = {
R: 55,
G: 110,
B: 165,
A: 255
};
var FILL_STYLE = "rgba(".concat(TestPixel.R, ", ").concat(TestPixel.G, ", ").concat(TestPixel.B, ", ").concat(TestPixel.A / 255, ")");
function canvasTest(width, height) {
// Wrapped into try/catch because memory alloction errors can be thrown due to insufficient RAM
try {
var fill = [width - 1, height - 1, 1, 1]; // x, y, width, height
var cropCvs = document.createElement('canvas');
cropCvs.width = 1;
cropCvs.height = 1;
var testCvs = document.createElement('canvas');
testCvs.width = width;
testCvs.height = height;
var cropCtx = cropCvs.getContext('2d');
var testCtx = testCvs.getContext('2d');
if (testCtx) {
testCtx.fillStyle = FILL_STYLE;
testCtx.fillRect.apply(testCtx, fill); // Render the test pixel in the bottom-right corner of the
// test canvas in the top-left of the 1x1 crop canvas. This
// dramatically reducing the time for getImageData to complete.
cropCtx.drawImage(testCvs, width - 1, height - 1, 1, 1, 0, 0, 1, 1);
}
var imageData = cropCtx && cropCtx.getImageData(0, 0, 1, 1).data;
var isTestPass = false;
if (imageData) {
// On IE10, imageData have type CanvasPixelArray, not Uint8ClampedArray.
// CanvasPixelArray supports index access operations only.
// Array buffers can't be destructuredd and compared with JSON.stringify
isTestPass = imageData[0] === TestPixel.R && imageData[1] === TestPixel.G && imageData[2] === TestPixel.B && imageData[3] === TestPixel.A;
}
testCvs.width = testCvs.height = 1;
return isTestPass;
} catch (e) {
log("Failed to test for max canvas size of ".concat(width, "x").concat(height, "."), e);
return false;
}
}
function memoize(fn, serializer) {
var cache = {};
return function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var key = serializer(args, cache);
return key in cache ? cache[key] : cache[key] = fn.apply(void 0, args);
};
}
var sizes = {
squareSide: [// Safari (iOS < 9, ram >= 256)
// We are supported mobile safari < 9 since widget v2, by 5 Mpx limit
// so it's better to continue support despite the absence of this browser in the support table
Math.floor(Math.sqrt(5 * 1000 * 1000)), // IE Mobile (Windows Phone 8.x)
// Safari (iOS >= 9)
4096, // IE 9 (Win)
8192, // Firefox 63 (Mac, Win)
11180, // Chrome 68 (Android 6)
10836, // Chrome 68 (Android 5)
11402, // Chrome 68 (Android 7.1-9)
14188, // Chrome 70 (Mac, Win)
// Chrome 68 (Android 4.4)
// Edge 17 (Win)
// Safari 7-12 (Mac)
16384],
dimension: [// IE Mobile (Windows Phone 8.x)
4096, // IE 9 (Win)
8192, // Edge 17 (Win)
// IE11 (Win)
16384, // Chrome 70 (Mac, Win)
// Chrome 68 (Android 4.4-9)
// Firefox 63 (Mac, Win)
32767, // Chrome 83 (Mac, Win)
// Safari 7-12 (Mac)
// Safari (iOS 9-12)
// Actually Safari has a much bigger limits - 4194303 of width and 8388607 of height,
// but we will not use them
65535]
};
var MAX_SQUARE_SIDE = sizes.squareSide[sizes.squareSide.length - 1];
function wrapAsync(fn) {
return function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var df = $__default["default"].Deferred();
defer(function () {
var passed = fn.apply(void 0, args);
df.resolve(passed);
});
return df.promise();
};
}
/**
* Memoization key serealizer, that prevents unnecessary canvas tests.
* No need to make test if we know that:
* - browser supports higher canvas size
* - browser doesn't support lower canvas size
*/
function memoKeySerializer(args, cache) {
var _args = _slicedToArray(args, 1),
w = _args[0];
var cachedWidths = Object.keys(cache).map(function (val) {
return parseInt(val, 10);
}).sort(function (a, b) {
return a - b;
});
for (var i = 0; i < cachedWidths.length; i++) {
var cachedWidth = cachedWidths[i];
var isSupported = !!cache[cachedWidth]; // higher supported canvas size, return it
if (cachedWidth > w && isSupported) {
return cachedWidth;
} // lower unsupported canvas size, return it
if (cachedWidth < w && !isSupported) {
return cachedWidth;
}
} // use canvas width as the key,
// because we're doing dimension test by width - [dimension, 1]
return w;
} // separate memoization for square and dimension tests
var squareTest = wrapAsync(memoize(canvasTest, memoKeySerializer));
var dimensionTest = wrapAsync(memoize(canvasTest, memoKeySerializer));
function testCanvasSize(w, h) {
var df = $__default["default"].Deferred();
var testSquareSide = sizes.squareSide.find(function (side) {
return side * side >= w * h;
});
var testDimension = sizes.dimension.find(function (side) {
return side >= w && side >= h;
});
if (!testSquareSide || !testDimension) {
return df.reject();
}
var tasks = [squareTest(testSquareSide, testSquareSide), dimensionTest(testDimension, 1)];
$__default["default"].when.apply($__default["default"], tasks).done(function (squareSupported, dimensionSupported) {
if (squareSupported && dimensionSupported) {
df.resolve();
} else {
df.reject();
}
});
return df.promise();
}
var indexOf$1 = [].indexOf; // settings
var arrayOptions, constrainOptions, constraints, defaultPreviewUrlCallback, defaults$1, initialSettings, flagOptions, intOptions, integration, integrationToUserAgent, buildRetryConfig, normalize, parseCrop, parseShrink, presets, script, str2arr, transformOptions, transforms, urlOptions, callbackOptions, objectOptions;
defaults$1 = {
// developer hooks
live: true,
manualStart: false,
locale: null,
localePluralize: null,
localeTranslations: null,
// widget & dialog settings
systemDialog: false,
crop: false,
previewStep: false,
imagesOnly: false,
clearable: false,
multiple: false,
multipleMax: 1000,
multipleMin: 1,
multipleMaxStrict: false,
imageShrink: false,
pathValue: true,
tabs: 'file camera url facebook gdrive gphotos dropbox instagram evernote flickr onedrive',
preferredTypes: '',
inputAcceptTypes: '',
// '' means default, null means "disable accept"
// upload settings
doNotStore: false,
publicKey: null,
secureSignature: '',
secureExpire: '',
pusherKey: '79ae88bd931ea68464d9',
cdnBase: 'https://ucarecdn.com',
urlBase: 'https://upload.uploadcare.com',
socialBase: 'https://social.uploadcare.com',
previewProxy: null,
previewUrlCallback: null,
remoteTabSessionKey: null,
metadata: null,
metadataCallback: null,
// fine tuning
imagePreviewMaxSize: 25 * 1024 * 1024,
multipartMinSize: 10 * 1024 * 1024,
multipartPartSize: 5 * 1024 * 1024,
multipartMinLastPartSize: 1024 * 1024,
multipartConcurrency: 4,
// `multipartMaxAttempts` is deprecated, value will be assigned to `retryAttempts` if set
multipartMaxAttempts: null,
retryAttempts: 3,
retryThrottledAttempts: 10,
retryBaseTimeout: 1000,
retryFactor: 2,
parallelDirectUploads: 10,
passWindowOpen: false,
// camera
cameraMirrorDefault: true,
// camera recording
enableAudioRecording: true,
enableVideoRecording: true,
videoPreferredMimeTypes: null,
audioBitsPerSecond: null,
videoBitsPerSecond: null,
// maintain settings
scriptBase: "//ucarecdn.com/widget/".concat(version, "/uploadcare/"),
debugUploads: false,
integration: ''
};
initialSettings = _objectSpread2({}, defaults$1);
transforms = {
multipleMax: {
from: 0,
to: 1000
}
};
constraints = {
multipleMax: {
min: 1,
max: 1000
}
};
presets = {
tabs: {
all: 'file camera url facebook gdrive gphotos dropbox instagram evernote flickr onedrive box vk huddle',
default: defaults$1.tabs
}
}; // integration setting from data attributes of script tag
script = isWindowDefined() && (document.currentScript || function () {
var scripts;
scripts = document.getElementsByTagName('script');
return scripts[scripts.length - 1];
}());
integration = isWindowDefined() && $__default["default"](script).data('integration');
if (integration && integration != null) {
defaults$1 = $__default["default"].extend(defaults$1, {
integration: integration
});
}
str2arr = function str2arr(value) {
if (!$__default["default"].isArray(value)) {
value = $__default["default"].trim(value);
value = value ? value.split(' ') : [];
}
return value;
};
arrayOptions = function arrayOptions(settings, keys) {
var hasOwnProperty = Object.prototype.hasOwnProperty;
var i, item, j, key, len, len1, source, value;
for (i = 0, len = keys.length; i < len; i++) {
key = keys[i];
value = source = str2arr(settings[key]);
if (hasOwnProperty.apply(presets, [key])) {
value = [];
for (j = 0, len1 = source.length; j < len1; j++) {
item = source[j];
if (hasOwnProperty.apply(presets[key], [item])) {
value = value.concat(str2arr(presets[key][item]));
} else {
value.push(item);
}
}
}
settings[key] = unique(value);
}
return settings;
};
urlOptions = function urlOptions(settings, keys) {
var i, key, len;
for (i = 0, len = keys.length; i < len; i++) {
key = keys[i];
if (settings[key] != null) {
settings[key] = normalizeUrl(settings[key]);
}
}
return settings;
};
flagOptions = function flagOptions(settings, keys) {
var i, key, len, value;
for (i = 0, len = keys.length; i < len; i++) {
key = keys[i];
if (!(settings[key] != null)) {
continue;
}
value = settings[key];
if (typeof value === 'string') {
// "", "..." -> true
// "false", "disabled" -> false
value = $__default["default"].trim(value).toLowerCase();
settings[key] = !(value === 'false' || value === 'disabled');
} else {
settings[key] = !!value;
}
}
return settings;
};
intOptions = function intOptions(settings, keys) {
var i, key, len;
for (i = 0, len = keys.length; i < len; i++) {
key = keys[i];
if (settings[key] != null) {
settings[key] = parseInt(settings[key]);
}
}
return settings;
};
integrationToUserAgent = function integrationToUserAgent(settings) {
settings._userAgent = "UploadcareWidget/".concat(version, "/").concat(settings.publicKey, " (JavaScript").concat(settings.integration ? "; ".concat(settings.integration) : '', ")");
return settings;
};
buildRetryConfig = function buildRetryConfig(settings) {
if (settings.retryAttempts === initialSettings.retryAttempts && settings.multipartMaxAttempts !== null) {
settings.retryAttempts = settings.multipartMaxAttempts;
}
settings.retryConfig = {
baseTimeout: settings.retryBaseTimeout,
factor: settings.retryFactor,
attempts: settings.retryAttempts,
debugUploads: settings.debugUploads,
throttledAttempts: settings.retryThrottledAttempts
};
};
transformOptions = function transformOptions(settings, transforms) {
var key, transform;
for (key in transforms) {
transform = transforms[key];
if (settings[key] != null) {
if (settings[key] === transform.from) {
settings[key] = transform.to;
}
}
}
return settings;
};
constrainOptions = function constrainOptions(settings, constraints) {
var key, max, min;
for (key in constraints) {
var _constraints$key = constraints[key];
min = _constraints$key.min;
max = _constraints$key.max;
if (settings[key] != null) {
settings[key] = Math.min(Math.max(settings[key], min), max);
}
}
return settings;
};
callbackOptions = function callbackOptions(settings, keys) {
for (var i = 0, len = keys.length; i < len; i++) {
var key = keys[i];
if (settings[key] && typeof settings[key] !== 'function') {
warnOnce("Option \"".concat(key, "\" is expected to be a function. Instead got: ").concat(_typeof(settings[key])));
}
}
};
objectOptions = function objectOptions(settings, keys) {
for (var i = 0, len = keys.length; i < len; i++) {
var key = keys[i];
if (settings[key] && !isObject(settings[key])) {
warnOnce("Option \"".concat(key, "\" is expected to be an object. Instead got: ").concat(_typeof(settings[key])));
}
}
};
parseCrop = function parseCrop(val) {
var ratio, reRatio;
reRatio = /^([0-9]+)([x:])([0-9]+)\s*(|upscale|minimum)$/i;
ratio = reRatio.exec($__default["default"].trim(val.toLowerCase())) || [];
return {
downscale: ratio[2] === 'x',
upscale: !!ratio[4],
notLess: ratio[4] === 'minimum',
preferedSize: ratio.length ? [+ratio[1], +ratio[3]] : undefined
};
};
parseShrink = function parseShrink(val) {
var reShrink = /^([0-9]+)x([0-9]+)(?:\s+(\d{1,2}|100)%)?$/i;
var shrink = reShrink.exec($__default["default"].trim(val.toLowerCase())) || [];
if (!shrink.length) {
return false;
}
var size = shrink[1] * shrink[2];
var maxSize = MAX_SQUARE_SIDE * MAX_SQUARE_SIDE;
if (size > maxSize) {
warnOnce("Shrinked size can not be larger than ".concat(Math.floor(maxSize / 1000 / 1000), "MP. ") + "You have set ".concat(shrink[1], "x").concat(shrink[2], " (") + "".concat(Math.ceil(size / 1000 / 100) / 10, "MP)."));
return false;
}
return {
quality: shrink[3] ? shrink[3] / 100 : undefined,
size: size
};
};
defaultPreviewUrlCallback = function defaultPreviewUrlCallback(url, info) {
var addAmpersand, addName, addQuery, queryPart;
if (!this.previewProxy) {
return url;
}
addQuery = !/\?/.test(this.previewProxy);
addName = addQuery || !/=$/.test(this.previewProxy);
addAmpersand = !addQuery && !/[&?=]$/.test(this.previewProxy);
queryPart = encodeURIComponent(url);
if (addName) {
queryPart = 'url=' + queryPart;
}
if (addAmpersand) {
queryPart = '&' + queryPart;
}
if (addQuery) {
queryPart = '?' + queryPart;
}
return this.previewProxy + queryPart;
};
normalize = function normalize(settings) {
arrayOptions(settings, ['tabs', 'preferredTypes', 'videoPreferredMimeTypes']);
urlOptions(settings, ['cdnBase', 'socialBase', 'urlBase', 'scriptBase']);
flagOptions(settings, ['doNotStore', 'imagesOnly', 'multiple', 'clearable', 'pathValue', 'previewStep', 'systemDialog', 'debugUploads', 'multipleMaxStrict', 'cameraMirrorDefault']);
intOptions(settings, ['multipleMax', 'multipleMin', 'multipartMinSize', 'multipartPartSize', 'multipartMinLastPartSize', 'multipartConcurrency', 'multipartMaxAttempts', 'retryAttempts', 'retryThrottledAttempts', 'retryBaseTimeout', 'retryFactor', 'parallelDirectUploads']);
callbackOptions(settings, ['previewUrlCallback', 'metadataCallback']);
objectOptions(settings, ['metadata']);
transformOptions(settings, transforms);
constrainOptions(settings, constraints);
integrationToUserAgent(settings);
buildRetryConfig(settings);
if (settings.crop !== false && !$__default["default"].isArray(settings.crop)) {
if (/^(disabled?|false|null)$/i.test(settings.crop)) {
settings.crop = false;
} else if ($__default["default"].isPlainObject(settings.crop)) {
// old format
settings.crop = [settings.crop];
} else {
settings.crop = $__default["default"].map(('' + settings.crop).split(','), parseCrop);
}
}
if (settings.imageShrink && !$__default["default"].isPlainObject(settings.imageShrink)) {
settings.imageShrink = parseShrink(settings.imageShrink);
}
if (settings.crop || settings.multiple) {
settings.previewStep = true;
}
if (!sendFileAPI) {
settings.systemDialog = false;
}
if (settings.validators) {
settings.validators = settings.validators.slice();
}
if (settings.previewProxy && !settings.previewUrlCallback) {
settings.previewUrlCallback = defaultPreviewUrlCallback;
}
var skydriveIndex = settings.tabs.indexOf('skydrive');
if (skydriveIndex !== -1) {
settings.tabs[skydriveIndex] = 'onedrive';
}
return settings;
}; // global variables only
var globals = function globals() {
var key, scriptSettings, value;
scriptSettings = {};
for (key in defaults$1) {
value = window["UPLOADCARE_".concat(upperCase(key))];
if (value != null) {
scriptSettings[key] = value;
}
}
return scriptSettings;
}; // Defaults + global variables + global overrides (once from uploadcare.start)
// Not publicly-accessible
var common = once(function (settings, ignoreGlobals) {
var result;
if (!ignoreGlobals) {
defaults$1 = $__default["default"].extend(defaults$1, globals());
}
result = normalize($__default["default"].extend(defaults$1, settings || {}));
waitForSettings.fire(result);
return result;
}); // Defaults + global variables + global overrides + local overrides
var build = function build(settings) {
var result;
result = $__default["default"].extend({}, common());
if (!$__default["default"].isEmptyObject(settings)) {
result = normalize($__default["default"].extend(result, settings));
}
return result;
};
var waitForSettings = isWindowDefined() && $__default["default"].Callbacks('once memory');
var CssCollector = /*#__PURE__*/function () {
function CssCollector() {
_classCallCheck(this, CssCollector);
this.urls = [];
this.styles = [];
}
_createClass(CssCollector, [{
key: "addUrl",
value: function addUrl(url) {
if (!/^https?:\/\//i.test(url)) {
throw new Error('Embedded urls should be absolute. ' + url);
}
if (!(indexOf$1.call(this.urls, url) >= 0)) {
return this.urls.push(url);
}
}
}, {
key: "addStyle",
value: function addStyle(style) {
return this.styles.push(style);
}
}]);
return CssCollector;
}();
var trackLoading = function trackLoading(image, src) {
var def;
def = $__default["default"].Deferred();
if (src) {
image.src = src;
}
if (image.complete) {
def.resolve(image);
} else {
$__default["default"](image).one('load', function () {
return def.resolve(image);
});
$__default["default"](image).one('error', function () {
return def.reject(image);
});
}
return def.promise();
};
var imageLoader = function imageLoader(image) {
// if argument is an array, treat as
// load(['1.jpg', '2.jpg'])
if ($__default["default"].isArray(image)) {
return $__default["default"].when.apply(null, $__default["default"].map(image, imageLoader));
}
if (image.src) {
return trackLoading(image);
} else {
return trackLoading(new window.Image(), image);
}
};
var videoLoader = function videoLoader(src) {
var def = $__default["default"].Deferred();
$__default["default"]('').on('loadeddata', def.resolve).on('error', def.reject).attr('src', src).get(0).load();
return def.promise();
};
var testImageSrc = 'data:image/jpg;base64,' + '/9j/4AAQSkZJRgABAQEASABIAAD/4QA6RXhpZgAATU0AKgAAAAgAAwESAAMAAAABAAYAAAEo' + 'AAMAAAABAAIAAAITAAMAAAABAAEAAAAAAAD/2wBDAP//////////////////////////////' + '////////////////////////////////////////////////////////wAALCAABAAIBASIA' + '/8QAJgABAAAAAAAAAAAAAAAAAAAAAxABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQAAPwBH/9k=';
var isApplied;
var isBrowserApplyExif = function isBrowserApplyExif() {
var df = $__default["default"].Deferred();
if (isApplied !== undefined) {
df.resolve(isApplied);
} else {
var image = new window.Image();
image.onload = function () {
isApplied = image.naturalWidth < image.naturalHeight;
image.src = '//:0';
df.resolve(isApplied);
};
image.src = testImageSrc;
}
return df.promise();
};
var resizeCanvas = function resizeCanvas(img, w, h) {
var df = $__default["default"].Deferred();
defer(function () {
try {
var canvas = document.createElement('canvas');
var cx = canvas.getContext('2d');
canvas.width = w;
canvas.height = h;
cx.imageSmoothingQuality = 'high';
cx.drawImage(img, 0, 0, w, h);
img.src = '//:0'; // for image
img.width = img.height = 1; // for canvas
df.resolve(canvas);
} catch (e) {
log("Failed to shrink image to size ".concat(w, "x").concat(h, "."), e);
df.reject(e);
}
});
return df.promise();
};
/**
* Goes from target to source by step, the last incomplete step is dropped.
* Always returns at least one step - target. Source step is not included.
* Sorted descending.
*
* Example with step = 0.71, source = 2000, target = 400
* 400 (target) <- 563 <- 793 <- 1117 <- 1574 (dropped) <- [2000 (source)]
*/
var calcShrinkSteps = function calcShrinkSteps(sourceW, targetW, targetH, step) {
var steps = [];
var sW = targetW;
var sH = targetH; // result should include at least one target step,
// even if abs(source - target) < step * source
// just to be sure nothing will break
// if the original resolution / target resolution condition changes
do {
steps.push([sW, sH]);
sW = Math.round(sW / step);
sH = Math.round(sH / step);
} while (sW < sourceW * step);
return steps.reverse();
};
/**
* Fallback resampling algorithm
*
* Reduces dimensions by step until reaches target dimensions,
* this gives a better output quality than one-step method
*
* Target dimensions expected to be supported by browser,
* unsupported steps will be dropped.
*/
var runFallback = function runFallback(img, sourceW, targetW, targetH, step) {
var steps = calcShrinkSteps(sourceW, targetW, targetH, step);
var seriesDf = $__default["default"].Deferred();
var chainedDf = $__default["default"].Deferred();
chainedDf.resolve(img);
var _iterator = _createForOfIteratorHelper(steps),
_step;
try {
var _loop = function _loop() {
var _step$value = _slicedToArray(_step.value, 2),
w = _step$value[0],
h = _step$value[1];
chainedDf = chainedDf.then(function (canvas) {
var df = $__default["default"].Deferred();
testCanvasSize(w, h).then(function () {
return df.resolve(canvas, false);
}).fail(function () {
return df.resolve(canvas, true);
});
return df.promise();
}).then(function (canvas, skip) {
return skip ? canvas : resizeCanvas(canvas, w, h);
}).then(function (canvas) {
seriesDf.notify((sourceW - w) / (sourceW - targetW));
return canvas;
});
};
for (_iterator.s(); !(_step = _iterator.n()).done;) {
_loop();
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
chainedDf.done(function (canvas) {
seriesDf.resolve(canvas);
});
chainedDf.fail(function (error) {
seriesDf.reject(error);
});
return seriesDf.promise();
};
/**
* Native high-quality canvas resampling
*
* Browser support: https://caniuse.com/mdn-api_canvasrenderingcontext2d_imagesmoothingenabled
* Target dimensions expected to be supported by browser.
*/
var runNative = function runNative(img, targetW, targetH) {
return resizeCanvas(img, targetW, targetH);
};
var shrinkImage = function shrinkImage(img, settings) {
// in -> image
// out <- canvas
var df = $__default["default"].Deferred(); // do not shrink image if original resolution / target resolution ratio falls behind 2.0
var STEP = 0.71; // should be > sqrt(0.5)
if (img.width * STEP * img.height * STEP < settings.size) {
return df.reject('not required');
}
var sourceW = img.width;
var sourceH = img.height;
var ratio = sourceW / sourceH; // target size shouldn't be greater than settings.size in any case
var targetW = Math.floor(Math.sqrt(settings.size * ratio));
var targetH = Math.floor(settings.size / Math.sqrt(settings.size * ratio)); // we test the last step because we can skip all intermediate steps
testCanvasSize(targetW, targetH).fail(function () {
df.reject('not supported');
}).then(function () {
var cx = document.createElement('canvas').getContext('2d');
var supportNative = ('imageSmoothingQuality' in cx); // native scaling on ios gives blurry results
var useNativeScaling = supportNative && !iOSVersion && !isIpadOs;
var task = useNativeScaling ? runNative(img, targetW, targetH) : runFallback(img, sourceW, targetW, targetH, STEP);
task.done(function (canvas) {
return df.resolve(canvas);
}).progress(function (progress) {
return df.notify(progress);
}).fail(function () {
return df.reject('not supported');
});
});
return df.promise();
};
var DataView = isWindowDefined() && window.DataView;
var runner = taskRunner(1);
var shrinkFile = function shrinkFile(file, settings) {
// in -> file
// out <- blob
var df = $__default["default"].Deferred();
if (!(URL && DataView && Blob)) {
return df.reject('support');
} // start = new Date()
runner(function (release) {
// console.log('delayed: ' + (new Date() - start))
df.always(release); // start = new Date()
var op = shouldSkipShrink(file).then(function (shouldSkip) {
if (shouldSkip) {
df.reject('skipped');
return $__default["default"].Deferred().reject();
}
}).then(function () {
return stripIccProfile(file).fail(function () {
df.reject('not image');
});
});
op.done(function (img) {
// console.log('load: ' + (new Date() - start))
df.notify(0.1);
var exifOp = $__default["default"].when(getExif(file), isBrowserApplyExif(), getIccProfile(file)).always(function (exif, isExifApplied, iccProfile) {
df.notify(0.2);
var isJPEG = exifOp.state() === 'resolved'; // start = new Date()
var op = shrinkImage(img, settings);
op.progress(function (progress) {
return df.notify(0.2 + progress * 0.6);
});
op.fail(df.reject);
op.done(function (canvas) {
// console.log('shrink: ' + (new Date() - start))
// start = new Date()
var format = 'image/jpeg';
var quality = settings.quality || 0.8;
if (!isJPEG && hasTransparency(canvas)) {
format = 'image/png';
quality = undefined;
}
canvasToBlob(canvas, format, quality, function (blob) {
canvas.width = canvas.height = 1;
df.notify(0.9); // console.log('to blob: ' + (new Date() - start))
var replaceChain = $__default["default"].Deferred().resolve(blob);
if (exif) {
replaceChain = replaceChain.then(function (blob) {
return replaceExif(blob, exif, isExifApplied);
}).catch(function () {
return blob;
});
}
if ((iccProfile === null || iccProfile === void 0 ? void 0 : iccProfile.length) > 0) {
replaceChain = replaceChain.then(function (blob) {
return replaceIccProfile(blob, iccProfile);
}).catch(function () {
return blob;
});
}
replaceChain.done(df.resolve);
replaceChain.fail(function () {
return df.resolve(blob);
});
});
});
});
});
});
return df.promise();
};
var drawFileToCanvas = function drawFileToCanvas(file, mW, mH, bg, maxSource) {
var df, op; // in -> file
// out <- canvas
df = $__default["default"].Deferred();
if (!URL) {
return df.reject('support');
}
op = imageLoader(URL.createObjectURL(file));
op.always(function (img) {
return URL.revokeObjectURL(img.src);
});
op.fail(function () {
return df.reject('not image');
});
op.done(function (img) {
df.always(function () {
img.src = '//:0';
});
if (maxSource && img.width * img.height > maxSource) {
return df.reject('max source');
}
return $__default["default"].when(getExif(file), isBrowserApplyExif()).always(function (exif, isExifApplied) {
var orientation = isExifApplied ? 1 : parseExifOrientation(exif) || 1;
var swap = orientation > 4;
var sSize = swap ? [img.height, img.width] : [img.width, img.height];
var _fitSize = fitSize(sSize, [mW, mH]),
_fitSize2 = _slicedToArray(_fitSize, 2),
dW = _fitSize2[0],
dH = _fitSize2[1];
var trns = [[1, 0, 0, 1, 0, 0], [-1, 0, 0, 1, dW, 0], [-1, 0, 0, -1, dW, dH], [1, 0, 0, -1, 0, dH], [0, 1, 1, 0, 0, 0], [0, 1, -1, 0, dW, 0], [0, -1, -1, 0, dW, dH], [0, -1, 1, 0, 0, dH]][orientation - 1];
if (!trns) {
return df.reject('bad image');
}
var canvas = document.createElement('canvas');
canvas.width = dW;
canvas.height = dH;
var ctx = canvas.getContext('2d');
ctx.transform.apply(ctx, trns);
if (swap) {
var _ref = [dH, dW];
dW = _ref[0];
dH = _ref[1];
}
if (bg) {
ctx.fillStyle = bg;
ctx.fillRect(0, 0, dW, dH);
}
ctx.drawImage(img, 0, 0, dW, dH);
return df.resolve(canvas, sSize);
});
});
return df.promise();
}; // Util functions
var readJpegChunks = function readJpegChunks(file) {
var df, pos, readNext, readNextChunk, readToView;
readToView = function readToView(file, cb) {
var reader;
reader = new FileReader();
reader.onload = function () {
return cb(new DataView(reader.result));
};
reader.onerror = function (e) {
return df.reject('reader', e);
};
return reader.readAsArrayBuffer(file);
};
readNext = function readNext() {
return readToView(file.slice(pos, pos + 128), function (view) {
var i, j, ref;
for (i = j = 0, ref = view.byteLength; ref >= 0 ? j < ref : j > ref; i = ref >= 0 ? ++j : --j) {
if (view.getUint8(i) === 0xff) {
pos += i;
break;
}
}
return readNextChunk();
});
};
readNextChunk = function readNextChunk() {
var startPos;
startPos = pos; // todo fix
// eslint-disable-next-line no-return-assign
return readToView(file.slice(pos, pos += 4), function (view) {
var length, marker;
if (view.byteLength !== 4 || view.getUint8(0) !== 0xff) {
return df.reject('corrupted');
}
marker = view.getUint8(1);
if (marker === 0xda) {
// Start Of Scan
// console.log('read jpeg chunks: ' + (new Date() - start))
return df.resolve();
}
length = view.getUint16(2) - 2; // eslint-disable-next-line no-return-assign
return readToView(file.slice(pos, pos += length), function (view) {
if (view.byteLength !== length) {
return df.reject('corrupted');
}
df.notify(startPos, length, marker, view);
return readNext();
});
});
};
df = $__default["default"].Deferred();
if (!(FileReader && DataView)) {
return df.reject('support');
} // start = new Date()
pos = 2;
readToView(file.slice(0, 2), function (view) {
if (view.getUint16(0) !== 0xffd8) {
return df.reject('not jpeg');
}
return readNext();
});
return df.promise();
};
var replaceJpegChunk = function replaceJpegChunk(blob, marker, chunks) {
var df, oldChunkLength, oldChunkPos, op;
df = $__default["default"].Deferred();
oldChunkPos = [];
oldChunkLength = [];
op = readJpegChunks(blob);
op.fail(df.reject);
op.progress(function (pos, length, oldMarker) {
if (oldMarker === marker) {
oldChunkPos.push(pos);
return oldChunkLength.push(length);
}
});
op.done(function () {
var chunk, i, intro, j, k, len, newChunks, pos, ref;
newChunks = [blob.slice(0, 2)];
for (j = 0, len = chunks.length; j < len; j++) {
chunk = chunks[j];
intro = new DataView(new ArrayBuffer(4));
intro.setUint16(0, 0xff00 + marker);
intro.setUint16(2, chunk.byteLength + 2);
newChunks.push(intro.buffer);
newChunks.push(chunk);
}
pos = 2;
for (i = k = 0, ref = oldChunkPos.length; ref >= 0 ? k < ref : k > ref; i = ref >= 0 ? ++k : --k) {
if (oldChunkPos[i] > pos) {
newChunks.push(blob.slice(pos, oldChunkPos[i]));
}
pos = oldChunkPos[i] + oldChunkLength[i] + 4;
}
newChunks.push(blob.slice(pos, blob.size));
return df.resolve(new Blob(newChunks, {
type: blob.type
}));
});
return df.promise();
};
var getExif = function getExif(file) {
var exif = null;
var op = readJpegChunks(file);
op.progress(function (pos, l, marker, view) {
if (!exif && marker === 0xe1) {
if (view.byteLength >= 14) {
if ( // check for "Exif\0"
view.getUint32(0) === 0x45786966 && view.getUint16(4) === 0) {
exif = view;
return exif;
}
}
}
});
return op.then(function () {
return exif;
}, function () {
return $__default["default"].Deferred().reject(exif);
});
};
var getIccProfile = function getIccProfile(file) {
var iccProfile = [];
var op = readJpegChunks(file);
op.progress(function (pos, l, marker, view) {
if (marker === 0xe2) {
if ( // check for "ICC_PROFILE\0"
view.getUint32(0) === 0x4943435f && view.getUint32(4) === 0x50524f46 && view.getUint32(8) === 0x494c4500) {
iccProfile.push(view);
}
}
});
return op.then(function () {
return iccProfile;
}, function () {
return $__default["default"].Deferred().reject(iccProfile);
});
};
var replaceExif = function replaceExif(blob, exif, isExifApplied) {
if (isExifApplied) {
setExifOrientation(exif, 1);
}
return replaceJpegChunk(blob, 0xe1, [exif.buffer]);
};
var replaceIccProfile = function replaceIccProfile(blob, iccProfile) {
return replaceJpegChunk(blob, 0xe2, iccProfile.map(function (chunk) {
return chunk.buffer;
}));
};
var stripIccProfile = function stripIccProfile(inputFile) {
var df = $__default["default"].Deferred();
replaceIccProfile(inputFile, []).catch(function () {
return inputFile;
}).then(function (file) {
var op = imageLoader(URL.createObjectURL(file));
op.always(function (img) {
URL.revokeObjectURL(img.src);
});
op.fail(function () {
df.reject();
});
op.done(function (img) {
df.resolve(img);
});
}).fail(function () {
df.reject();
});
return df.promise();
};
var shouldSkipShrink = function shouldSkipShrink(file) {
var allowLayers = [1, // L (black-white)
3 // RGB
];
var markers = [0xc0, // ("SOF0", "Baseline DCT", SOF)
0xc1, // ("SOF1", "Extended Sequential DCT", SOF)
0xc2, // ("SOF2", "Progressive DCT", SOF)
0xc3, // ("SOF3", "Spatial lossless", SOF)
0xc5, // ("SOF5", "Differential sequential DCT", SOF)
0xc6, // ("SOF6", "Differential progressive DCT", SOF)
0xc7, // ("SOF7", "Differential spatial", SOF)
0xc9, // ("SOF9", "Extended sequential DCT (AC)", SOF)
0xca, // ("SOF10", "Progressive DCT (AC)", SOF)
0xcb, // ("SOF11", "Spatial lossless DCT (AC)", SOF)
0xcd, // ("SOF13", "Differential sequential DCT (AC)", SOF)
0xce, // ("SOF14", "Differential progressive DCT (AC)", SOF)
0xcf // ("SOF15", "Differential spatial (AC)", SOF)
];
var skip = false;
var op = readJpegChunks(file);
op.progress(function (pos, l, marker, view) {
if (!skip && markers.indexOf(marker) >= 0) {
var layer = view.getUint8(5);
if (allowLayers.indexOf(layer) < 0) {
skip = true;
}
}
});
return op.then(function () {
return skip;
}).catch(function () {
return skip;
});
};
var setExifOrientation = function setExifOrientation(exif, orientation) {
findExifOrientation(exif, function (offset, little) {
return exif.setUint16(offset, orientation, little);
});
};
var parseExifOrientation = function parseExifOrientation(exif) {
return findExifOrientation(exif, function (offset, little) {
return exif.getUint16(offset, little);
});
};
var findExifOrientation = function findExifOrientation(exif, exifCallback) {
var count, j, little, offset, ref;
if (!exif || exif.byteLength < 14 || exif.getUint32(0) !== 0x45786966 || exif.getUint16(4) !== 0) {
return null;
}
if (exif.getUint16(6) === 0x4949) {
little = true;
} else if (exif.getUint16(6) === 0x4d4d) {
little = false;
} else {
return null;
}
if (exif.getUint16(8, little) !== 0x002a) {
return null;
}
offset = 8 + exif.getUint32(10, little);
count = exif.getUint16(offset - 2, little);
for (j = 0, ref = count; ref >= 0 ? j < ref : j > ref; ref >= 0 ? ++j : --j) {
if (exif.byteLength < offset + 10) {
return null;
}
if (exif.getUint16(offset, little) === 0x0112) {
return exifCallback(offset + 8, little);
}
offset += 12;
}
return null;
};
var hasTransparency = function hasTransparency(img) {
var canvas, ctx, data, i, j, pcsn, ref;
pcsn = 50;
canvas = document.createElement('canvas');
canvas.width = canvas.height = pcsn;
ctx = canvas.getContext('2d');
ctx.drawImage(img, 0, 0, pcsn, pcsn);
data = ctx.getImageData(0, 0, pcsn, pcsn).data;
canvas.width = canvas.height = 1;
for (i = j = 3, ref = data.length; j < ref; i = j += 4) {
if (data[i] < 254) {
return true;
}
}
return false;
};
// progressState: one of 'error', 'ready', 'uploading', 'uploaded'
// internal api
// __notifyApi: file upload in progress
// __resolveApi: file is ready
// __rejectApi: file failed on any stage
// __completeUpload: file uploaded, info required
var BaseFile = /*#__PURE__*/function () {
function BaseFile(param, settings1) {
var sourceInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
_classCallCheck(this, BaseFile);
var base;
this.settings = settings1;
this.sourceInfo = sourceInfo;
this.fileId = null;
this.fileName = null;
this.sanitizedName = null;
this.fileSize = null;
this.isStored = null;
this.cdnUrlModifiers = null;
this.isImage = null;
this.imageInfo = null;
this.videoInfo = null;
this.contentInfo = null;
this.mimeType = null;
this.s3Bucket = null;
this.metadata = null;
(base = this.sourceInfo).source || (base.source = this.sourceName);
this.__setupValidation();
this.__initApi();
}
_createClass(BaseFile, [{
key: "__startUpload",
value: function __startUpload() {
return $__default["default"].Deferred().resolve();
}
}, {
key: "__completeUpload",
value: function __completeUpload() {
var _this = this;
var _check, logger, ncalls, timeout; // Update info until @apiDeferred resolved.
ncalls = 0;
if (this.settings.debugUploads) {
debug('Load file info.', this.fileId, this.settings.publicKey);
logger = setInterval(function () {
return debug('Still waiting for file ready.', ncalls, _this.fileId, _this.settings.publicKey);
}, 5000);
this.apiDeferred.done(function () {
return debug('File uploaded.', ncalls, _this.fileId, _this.settings.publicKey);
}).always(function () {
return clearInterval(logger);
});
}
timeout = 100;
return (_check = function check() {
if (_this.apiDeferred.state() === 'pending') {
ncalls += 1;
return _this.__updateInfo().done(function () {
setTimeout(_check, timeout);
timeout += 50;
return timeout;
});
}
})();
}
}, {
key: "__updateInfo",
value: function __updateInfo() {
var _this2 = this;
return jsonp("".concat(this.settings.urlBase, "/info/"), 'GET', {
jsonerrors: 1,
file_id: this.fileId,
pub_key: this.settings.publicKey,
// Assume that we have all other info if isImage is set to something
// other than null and we only waiting for is_ready flag.
wait_is_ready: +(this.isImage === null)
}, {
headers: {
'X-UC-User-Agent': this.settings._userAgent
},
retryConfig: this.settings.retryConfig
}).fail(function (error) {
if (_this2.settings.debugUploads) {
log("Can't load file info. Probably removed.", _this2.fileId, _this2.settings.publicKey, error.message);
}
return _this2.__rejectApi('info', error);
}).done(this.__handleFileData.bind(this));
}
}, {
key: "__handleFileData",
value: function __handleFileData(data) {
this.fileName = data.original_filename;
this.sanitizedName = data.filename;
this.fileSize = data.size;
this.isImage = data.is_image;
this.imageInfo = data.image_info;
this.videoInfo = data.video_info;
this.contentInfo = data.content_info;
this.mimeType = data.mime_type;
this.isStored = data.is_stored;
this.s3Bucket = data.s3_bucket;
this.metadata = data.metadata;
if (data.default_effects) {
this.cdnUrlModifiers = '-/' + data.default_effects;
}
if (this.s3Bucket && this.cdnUrlModifiers) {
this.__rejectApi('baddata');
}
this.__runValidators();
if (data.is_ready) {
return this.__resolveApi();
}
} // Retrieve info
}, {
key: "__progressInfo",
value: function __progressInfo() {
var ref;
return {
state: this.__progressState,
uploadProgress: this.__progress,
progress: (ref = this.__progressState) === 'ready' || ref === 'error' ? 1 : this.__progress * 0.9,
incompleteFileInfo: this.__fileInfo()
};
}
}, {
key: "__fileInfo",
value: function __fileInfo() {
var urlBase;
if (this.s3Bucket) {
urlBase = "https://".concat(this.s3Bucket, ".s3.amazonaws.com/").concat(this.fileId, "/").concat(this.sanitizedName);
} else {
urlBase = "".concat(this.settings.cdnBase, "/").concat(this.fileId, "/");
}
return {
uuid: this.fileId,
name: this.fileName,
size: this.fileSize,
isStored: this.isStored,
isImage: !this.s3Bucket && this.isImage,
originalImageInfo: this.imageInfo,
originalVideoInfo: this.videoInfo,
originalContentInfo: this.contentInfo,
mimeType: this.mimeType,
originalUrl: this.fileId ? urlBase : null,
cdnUrl: this.fileId ? "".concat(urlBase).concat(this.cdnUrlModifiers || '') : null,
cdnUrlModifiers: this.cdnUrlModifiers,
sourceInfo: this.sourceInfo,
metadata: this.metadata
};
} // Validators
}, {
key: "__setupValidation",
value: function __setupValidation() {
this.validators = this.settings.validators || this.settings.__validators || [];
if (this.settings.imagesOnly) {
return this.validators.push(function (info) {
if (info.isImage === false) {
throw new Error('image');
}
});
}
}
}, {
key: "__runValidators",
value: function __runValidators() {
var err, i, info, len, ref, results, v;
info = this.__fileInfo();
try {
ref = this.validators;
results = [];
for (i = 0, len = ref.length; i < len; i++) {
v = ref[i];
results.push(v(info));
}
return results;
} catch (error) {
err = error;
return this.__rejectApi(err.message);
}
} // Internal API control
}, {
key: "__initApi",
value: function __initApi() {
this.apiDeferred = $__default["default"].Deferred();
this.__progressState = 'uploading';
this.__progress = 0;
return this.__notifyApi();
}
}, {
key: "__notifyApi",
value: function __notifyApi() {
return this.apiDeferred.notify(this.__progressInfo());
}
}, {
key: "__rejectApi",
value: function __rejectApi(errorType, err) {
this.__progressState = 'error';
this.__notifyApi();
return this.apiDeferred.reject(errorType, this.__fileInfo(), err);
}
}, {
key: "__resolveApi",
value: function __resolveApi() {
this.__progressState = 'ready';
this.__notifyApi();
return this.apiDeferred.resolve(this.__fileInfo());
}
}, {
key: "__cancel",
value: function __cancel() {
return this.__rejectApi('user');
}
}, {
key: "__extendApi",
value: function __extendApi(api) {
var _this3 = this;
api.cancel = this.__cancel.bind(this);
api.pipe = api.then = function () {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
// 'pipe' is alias to 'then' from jQuery 1.8
return _this3.__extendApi(fixedPipe.apply(void 0, [api].concat(args)));
};
return api; // extended promise
}
}, {
key: "promise",
value: function promise() {
var _this4 = this;
var op;
if (!this.__apiPromise) {
this.__apiPromise = this.__extendApi(this.apiDeferred.promise());
this.__runValidators();
if (this.apiDeferred.state() === 'pending') {
op = this.__startUpload();
op.done(function () {
_this4.__progressState = 'uploaded';
_this4.__progress = 1;
_this4.__notifyApi();
return _this4.__completeUpload();
});
op.progress(function (progress) {
if (progress > _this4.__progress) {
_this4.__progress = progress;
return _this4.__notifyApi();
}
});
op.fail(function (error) {
return _this4.__rejectApi('upload', error);
});
this.apiDeferred.always(op.reject);
}
}
return this.__apiPromise;
}
}]);
return BaseFile;
}();
var _directRunner = null;
var ObjectFile = /*#__PURE__*/function (_BaseFile) {
_inherits(ObjectFile, _BaseFile);
var _super = _createSuper(ObjectFile);
function ObjectFile(__file) {
var _this;
_classCallCheck(this, ObjectFile);
_this = _super.apply(this, arguments);
_this.__file = __file;
_this.fileName = _this.__file.name || 'original';
_this.__notifyApi();
return _this;
}
_createClass(ObjectFile, [{
key: "setFile",
value: function setFile(file) {
if (file) {
this.__file = file;
}
this.sourceInfo.file = this.__file;
if (!this.__file) {
return;
}
this.fileSize = this.__file.size;
this.fileType = this.__file.type || 'application/octet-stream';
if (this.settings.debugUploads) {
debug('Use local file.', this.fileName, this.fileType, this.fileSize);
}
this.__runValidators();
return this.__notifyApi();
}
}, {
key: "__startUpload",
value: function __startUpload() {
var _this2 = this;
var df, ios, resizeShare;
this.apiDeferred.always(function () {
_this2.__file = null;
return _this2.__file;
});
if (this.__file.size >= this.settings.multipartMinSize && Blob) {
this.setFile();
return this.multipartUpload();
}
ios = iOSVersion;
if (!this.settings.imageShrink || ios && ios < 8) {
this.setFile();
return this.directUpload();
} // if @settings.imageShrink
df = $__default["default"].Deferred();
resizeShare = 0.4;
shrinkFile(this.__file, this.settings.imageShrink).progress(function (progress) {
return df.notify(progress * resizeShare);
}).done(this.setFile.bind(this)).fail(function () {
_this2.setFile();
resizeShare = resizeShare * 0.1;
return resizeShare;
}).always(function () {
df.notify(resizeShare);
return _this2.directUpload().done(df.resolve).fail(df.reject).progress(function (progress) {
return df.notify(resizeShare + progress * (1 - resizeShare));
});
});
return df;
}
}, {
key: "__autoAbort",
value: function __autoAbort(xhr) {
this.apiDeferred.fail(function () {
return xhr.abort();
});
return xhr;
}
}, {
key: "directRunner",
value: function directRunner(task) {
if (!_directRunner) {
_directRunner = taskRunner(this.settings.parallelDirectUploads);
}
return _directRunner(task);
}
}, {
key: "directUpload",
value: function directUpload() {
var _this3 = this;
var df;
df = $__default["default"].Deferred();
if (!this.__file) {
this.__rejectApi('baddata');
return df;
}
if (this.fileSize > 100 * 1024 * 1024) {
this.__rejectApi('size');
return df;
}
this.directRunner(function (release) {
df.always(release);
if (_this3.apiDeferred.state() !== 'pending') {
return;
}
var formData = new window.FormData();
formData.append('UPLOADCARE_PUB_KEY', _this3.settings.publicKey);
formData.append('signature', _this3.settings.secureSignature);
formData.append('expire', _this3.settings.secureExpire);
formData.append('UPLOADCARE_STORE', _this3.settings.doNotStore ? '' : 'auto');
formData.append('file', _this3.__file, _this3.fileName);
formData.append('file_name', _this3.fileName);
formData.append('source', _this3.sourceInfo.source);
$__default["default"].each(getMetadataObject(_this3.settings), function (key, value) {
formData.append("metadata[".concat(key, "]"), value);
});
return _this3.__autoAbort($__default["default"].ajax({
xhr: function xhr() {
var xhr; // Naked XHR for progress tracking
xhr = $__default["default"].ajaxSettings.xhr();
if (xhr.upload) {
xhr.upload.addEventListener('progress', function (e) {
return df.notify(e.loaded / e.total);
}, false);
}
return xhr;
},
crossDomain: true,
type: 'POST',
url: "".concat(_this3.settings.urlBase, "/base/?jsonerrors=1"),
headers: {
'X-UC-User-Agent': _this3.settings._userAgent
},
contentType: false,
// For correct boundary string
processData: false,
data: formData,
dataType: 'json'
}).retry(_this3.settings.retryConfig).done(function (data) {
if (data != null ? data.file : undefined) {
_this3.fileId = data.file;
return df.resolve();
} else if (data.error) {
var _data$error = data.error,
message = _data$error.content,
code = _data$error.error_code;
return df.reject({
message: message,
code: code
});
} else {
return df.reject();
}
}).fail(df.reject));
});
return df;
}
}, {
key: "multipartUpload",
value: function multipartUpload() {
var _this4 = this;
var df;
df = $__default["default"].Deferred();
if (!this.__file) {
return df;
}
this.multipartStart().done(function (data) {
return _this4.uploadParts(data.parts, data.uuid).done(function () {
return _this4.multipartComplete(data.uuid).done(function (data) {
_this4.fileId = data.uuid;
_this4.__handleFileData(data);
return df.resolve();
}).fail(df.reject);
}).progress(df.notify).fail(df.reject);
}).fail(df.reject);
return df;
}
}, {
key: "multipartStart",
value: function multipartStart() {
var _this5 = this;
var data = {
UPLOADCARE_PUB_KEY: this.settings.publicKey,
signature: this.settings.secureSignature,
expire: this.settings.secureExpire,
filename: this.fileName,
source: this.sourceInfo.source,
size: this.fileSize,
content_type: this.fileType,
part_size: this.settings.multipartPartSize,
UPLOADCARE_STORE: this.settings.doNotStore ? '' : 'auto'
};
$__default["default"].each(getMetadataObject(this.settings), function (key, value) {
data["metadata[".concat(key, "]")] = value;
});
return this.__autoAbort(jsonp("".concat(this.settings.urlBase, "/multipart/start/?jsonerrors=1"), 'POST', data, {
headers: {
'X-UC-User-Agent': this.settings._userAgent
},
retryConfig: this.settings.retryConfig
})).fail(function (error) {
if (_this5.settings.debugUploads) {
return log("Can't start multipart upload.", error.message, data);
}
});
}
}, {
key: "uploadParts",
value: function uploadParts(parts, uuid) {
var _this6 = this;
var df, inProgress, j, lastUpdate, progress, ref1, _submit, submittedBytes, submittedParts, updateProgress;
progress = [];
lastUpdate = Date.now();
updateProgress = function updateProgress(i, loaded) {
var j, len, total;
progress[i] = loaded;
if (Date.now() - lastUpdate < 250) {
return;
}
lastUpdate = Date.now();
total = 0;
for (j = 0, len = progress.length; j < len; j++) {
loaded = progress[j];
total += loaded;
}
return df.notify(total / _this6.fileSize);
};
df = $__default["default"].Deferred();
inProgress = 0;
submittedParts = 0;
submittedBytes = 0;
_submit = function submit() {
if (submittedBytes >= _this6.fileSize) {
return;
}
var bytesToSubmit = submittedBytes + _this6.settings.multipartPartSize;
if (_this6.fileSize < bytesToSubmit + _this6.settings.multipartMinLastPartSize) {
bytesToSubmit = _this6.fileSize;
}
var blob = _this6.__file.slice(submittedBytes, bytesToSubmit);
submittedBytes = bytesToSubmit;
var partNo = submittedParts;
inProgress += 1;
submittedParts += 1;
return function () {
if (_this6.apiDeferred.state() !== 'pending') {
return;
}
progress[partNo] = 0;
return _this6.__autoAbort($__default["default"].ajax({
xhr: function xhr() {
var xhr; // Naked XHR for progress tracking
xhr = $__default["default"].ajaxSettings.xhr();
xhr.responseType = 'text';
if (xhr.upload) {
xhr.upload.addEventListener('progress', function (e) {
return updateProgress(partNo, e.loaded);
}, false);
}
return xhr;
},
url: parts[partNo],
crossDomain: true,
type: 'PUT',
processData: false,
contentType: _this6.fileType,
data: blob
}).retry(_objectSpread2(_objectSpread2({}, _this6.settings.retryConfig), {}, {
onAttemptFail: function onAttemptFail(_ref) {
var attempt = _ref.attempt;
if (_this6.settings.debugUploads) {
debug("Part #".concat(partNo, "(").concat(attempt, ") upload is failed."), uuid);
}
}
})).done(function () {
inProgress -= 1;
_submit();
if (!inProgress) {
return df.resolve();
}
}).fail(function () {
if (_this6.settings.debugUploads) {
log("Part #".concat(partNo, " and file upload is failed."), uuid);
}
return df.reject();
}));
}();
};
for (j = 0, ref1 = this.settings.multipartConcurrency; ref1 >= 0 ? j < ref1 : j > ref1; ref1 >= 0 ? ++j : --j) {
_submit();
}
return df;
}
}, {
key: "multipartComplete",
value: function multipartComplete(uuid) {
var _this7 = this;
var data;
data = {
UPLOADCARE_PUB_KEY: this.settings.publicKey,
uuid: uuid
};
return this.__autoAbort(jsonp("".concat(this.settings.urlBase, "/multipart/complete/?jsonerrors=1"), 'POST', data, {
headers: {
'X-UC-User-Agent': this.settings._userAgent
},
retryConfig: this.settings.retryConfig
})).fail(function (error) {
if (_this7.settings.debugUploads) {
return log("Can't complete multipart upload.", uuid, _this7.settings.publicKey, error.message);
}
});
}
}]);
return ObjectFile;
}(BaseFile);
ObjectFile.prototype.sourceName = 'local';
var InputFile = /*#__PURE__*/function (_BaseFile) {
_inherits(InputFile, _BaseFile);
var _super = _createSuper(InputFile);
function InputFile(__input) {
var _this;
_classCallCheck(this, InputFile);
_this = _super.apply(this, arguments);
_this.__input = __input;
_this.fileId = uuid();
_this.fileName = $__default["default"](_this.__input).val().split('\\').pop();
_this.__notifyApi();
return _this;
}
_createClass(InputFile, [{
key: "__startUpload",
value: function __startUpload() {
var df, formParam, iframeId, targetUrl;
df = $__default["default"].Deferred();
targetUrl = "".concat(this.settings.urlBase, "/iframe/");
iframeId = "uploadcare--iframe-".concat(this.fileId);
this.__iframe = $__default["default"]('