imagekit-javascript/dist/imagekit.esm.js

Javascript SDK for using ImageKit.io in the browser

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _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);
  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 ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (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 = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

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 _createForOfIteratorHelper(o, allowArrayLike) {
  var it;

  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
    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 = o[Symbol.iterator]();
    },
    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;
      }
    }
  };
}

var errorMessages = {
  MANDATORY_INITIALIZATION_MISSING: {
    message: "Missing urlEndpoint during SDK initialization",
    help: ""
  },
  INVALID_TRANSFORMATION_POSITION: {
    message: "Invalid transformationPosition parameter",
    help: ""
  },
  PRIVATE_KEY_CLIENT_SIDE: {
    message: "privateKey should not be passed on the client side",
    help: ""
  },
  MISSING_UPLOAD_DATA: {
    message: "Missing data for upload",
    help: ""
  },
  MISSING_UPLOAD_FILE_PARAMETER: {
    message: "Missing file parameter for upload",
    help: ""
  },
  MISSING_UPLOAD_FILENAME_PARAMETER: {
    message: "Missing fileName parameter for upload",
    help: ""
  },
  MISSING_AUTHENTICATION_ENDPOINT: {
    message: "Missing authentication endpoint for upload",
    help: ""
  },
  MISSING_PUBLIC_KEY: {
    message: "Missing public key for upload",
    help: ""
  },
  AUTH_ENDPOINT_TIMEOUT: {
    message: "The authenticationEndpoint you provided timed out in 60 seconds",
    help: ""
  },
  AUTH_ENDPOINT_NETWORK_ERROR: {
    message: "Request to authenticationEndpoint failed due to network error",
    help: ""
  },
  AUTH_INVALID_RESPONSE: {
    message: "Invalid response from authenticationEndpoint. The SDK expects a JSON response with three fields i.e. signature, token and expire.",
    help: ""
  },
  UPLOAD_ENDPOINT_NETWORK_ERROR: {
    message: "Request to ImageKit upload endpoint failed due to network error",
    help: ""
  },
  INVALID_UPLOAD_OPTIONS: {
    message: "Invalid uploadOptions parameter",
    help: ""
  },
  MISSING_SIGNATURE: {
    message: "Missing signature for upload. The SDK expects token, signature and expire for authentication.",
    help: ""
  },
  MISSING_TOKEN: {
    message: "Missing token for upload. The SDK expects token, signature and expire for authentication.",
    help: ""
  },
  MISSING_EXPIRE: {
    message: "Missing expire for upload. The SDK expects token, signature and expire for authentication.",
    help: ""
  },
  INVALID_TRANSFORMATION: {
    message: "Invalid transformation parameter. Please include at least pre, post, or both.",
    help: ""
  },
  INVALID_PRE_TRANSFORMATION: {
    message: "Invalid pre transformation parameter.",
    help: ""
  },
  INVALID_POST_TRANSFORMATION: {
    message: "Invalid post transformation parameter.",
    help: ""
  }
};

function respond (isError, response, callback) {
  if (typeof callback == "function") {
    if (isError) {
      callback(response, null);
    } else {
      callback(null, response);
    }
  }
}

function getResponseHeaderMap(xhr) {
  var headers = {};
  var responseHeaders = xhr.getAllResponseHeaders();
  if (Object.keys(responseHeaders).length) {
    responseHeaders.trim().split(/[\r\n]+/).map(function (value) {
      return value.split(/: /);
    }).forEach(function (keyValue) {
      headers[keyValue[0].trim()] = keyValue[1].trim();
    });
  }
  return headers;
}
var addResponseHeadersAndBody = function addResponseHeadersAndBody(body, xhr) {
  var response = _objectSpread2({}, body);
  var responseMetadata = {
    statusCode: xhr.status,
    headers: getResponseHeaderMap(xhr)
  };
  Object.defineProperty(response, "$ResponseMetadata", {
    value: responseMetadata,
    enumerable: false,
    writable: false
  });
  return response;
};
var request = function request(uploadFileXHR, formData, callback) {
  uploadFile(uploadFileXHR, formData).then(function (result) {
    return respond(false, result, callback);
  }, function (ex) {
    return respond(true, ex, callback);
  });
};
var uploadFile = function uploadFile(uploadFileXHR, formData) {
  return new Promise(function (resolve, reject) {
    uploadFileXHR.open('POST', 'https://upload.imagekit.io/api/v1/files/upload');
    uploadFileXHR.onerror = function (e) {
      return reject(errorMessages.UPLOAD_ENDPOINT_NETWORK_ERROR);
    };
    uploadFileXHR.onload = function () {
      if (uploadFileXHR.status === 200) {
        try {
          var body = JSON.parse(uploadFileXHR.responseText);
          var uploadResponse = addResponseHeadersAndBody(body, uploadFileXHR);
          return resolve(uploadResponse);
        } catch (ex) {
          return reject(ex);
        }
      } else {
        try {
          var body = JSON.parse(uploadFileXHR.responseText);
          var uploadError = addResponseHeadersAndBody(body, uploadFileXHR);
          return reject(uploadError);
        } catch (ex) {
          return reject(ex);
        }
      }
    };
    uploadFileXHR.send(formData);
  });
};

var upload = function upload(xhr, uploadOptions, options, callback) {
  if (!uploadOptions.file) {
    respond(true, errorMessages.MISSING_UPLOAD_FILE_PARAMETER, callback);
    return;
  }
  if (!uploadOptions.fileName) {
    respond(true, errorMessages.MISSING_UPLOAD_FILENAME_PARAMETER, callback);
    return;
  }
  if (!options.publicKey) {
    respond(true, errorMessages.MISSING_PUBLIC_KEY, callback);
    return;
  }
  if (!uploadOptions.token) {
    respond(true, errorMessages.MISSING_TOKEN, callback);
    return;
  }
  if (!uploadOptions.signature) {
    respond(true, errorMessages.MISSING_SIGNATURE, callback);
    return;
  }
  if (!uploadOptions.expire) {
    respond(true, errorMessages.MISSING_EXPIRE, callback);
    return;
  }
  if (uploadOptions.transformation) {
    if (!(Object.keys(uploadOptions.transformation).includes("pre") || Object.keys(uploadOptions.transformation).includes("post"))) {
      respond(true, errorMessages.INVALID_TRANSFORMATION, callback);
      return;
    }
    if (Object.keys(uploadOptions.transformation).includes("pre") && !uploadOptions.transformation.pre) {
      respond(true, errorMessages.INVALID_PRE_TRANSFORMATION, callback);
      return;
    }
    if (Object.keys(uploadOptions.transformation).includes("post")) {
      if (Array.isArray(uploadOptions.transformation.post)) {
        var _iterator = _createForOfIteratorHelper(uploadOptions.transformation.post),
            _step;
        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var transformation = _step.value;
            if (transformation.type === "abs" && !(transformation.protocol || transformation.value)) {
              respond(true, errorMessages.INVALID_POST_TRANSFORMATION, callback);
              return;
            } else if (transformation.type === "transformation" && !transformation.value) {
              respond(true, errorMessages.INVALID_POST_TRANSFORMATION, callback);
              return;
            }
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
      } else {
        respond(true, errorMessages.INVALID_POST_TRANSFORMATION, callback);
        return;
      }
    }
  }
  var formData = new FormData();
  var key;
  for (key in uploadOptions) {
    if (key) {
      if (key === "file" && typeof uploadOptions.file != "string") {
        formData.append('file', uploadOptions.file, String(uploadOptions.fileName));
      } else if (key === "tags" && Array.isArray(uploadOptions.tags)) {
        formData.append('tags', uploadOptions.tags.join(","));
      } else if (key === 'signature') {
        formData.append("signature", uploadOptions.signature);
      } else if (key === 'expire') {
        formData.append("expire", String(uploadOptions.expire));
      } else if (key === 'token') {
        formData.append("token", uploadOptions.token);
      } else if (key === "responseFields" && Array.isArray(uploadOptions.responseFields)) {
        formData.append('responseFields', uploadOptions.responseFields.join(","));
      } else if (key === "extensions" && Array.isArray(uploadOptions.extensions)) {
        formData.append('extensions', JSON.stringify(uploadOptions.extensions));
      } else if (key === "customMetadata" && _typeof(uploadOptions.customMetadata) === "object" && !Array.isArray(uploadOptions.customMetadata) && uploadOptions.customMetadata !== null) {
        formData.append('customMetadata', JSON.stringify(uploadOptions.customMetadata));
      } else if (key === "transformation" && _typeof(uploadOptions.transformation) === "object" && uploadOptions.transformation !== null) {
        formData.append(key, JSON.stringify(uploadOptions.transformation));
      } else if (key === 'checks' && uploadOptions.checks) {
        formData.append("checks", uploadOptions.checks);
      } else if (uploadOptions[key] !== undefined) {
        formData.append(key, String(uploadOptions[key]));
      }
    }
  }
  formData.append("publicKey", options.publicKey);
  request(xhr, formData, callback);
};

var supportedTransforms = {
  width: "w",
  height: "h",
  aspectRatio: "ar",
  background: "bg",
  border: "b",
  crop: "c",
  cropMode: "cm",
  dpr: "dpr",
  focus: "fo",
  quality: "q",
  x: "x",
  xCenter: "xc",
  y: "y",
  yCenter: "yc",
  format: "f",
  videoCodec: "vc",
  audioCodec: "ac",
  radius: "r",
  rotation: "rt",
  blur: "bl",
  named: "n",
  defaultImage: "di",
  flip: "fl",
  original: "orig",
  startOffset: "so",
  endOffset: "eo",
  duration: "du",
  streamingResolutions: "sr",
  grayscale: "e-grayscale",
  aiUpscale: "e-upscale",
  aiRetouch: "e-retouch",
  aiVariation: "e-genvar",
  aiDropShadow: "e-dropshadow",
  aiChangeBackground: "e-changebg",
  aiRemoveBackground: "e-bgremove",
  aiRemoveBackgroundExternal: "e-removedotbg",
  contrastStretch: "e-contrast",
  shadow: "e-shadow",
  sharpen: "e-sharpen",
  unsharpMask: "e-usm",
  gradient: "e-gradient",
  progressive: "pr",
  lossless: "lo",
  colorProfile: "cp",
  metadata: "md",
  opacity: "o",
  trim: "t",
  zoom: "z",
  page: "pg",
  fontSize: "fs",
  fontFamily: "ff",
  fontColor: "co",
  innerAlignment: "ia",
  padding: "pa",
  alpha: "al",
  typography: "tg",
  lineHeight: "lh",
  fontOutline: "fol",
  fontShadow: "fsh",
  raw: "raw"
};

var QUERY_TRANSFORMATION_POSITION = "query";
var PATH_TRANSFORMATION_POSITION = "path";
var DEFAULT_TRANSFORMATION_POSITION = QUERY_TRANSFORMATION_POSITION;
var VALID_TRANSFORMATION_POSITIONS = [PATH_TRANSFORMATION_POSITION, QUERY_TRANSFORMATION_POSITION];
var CHAIN_TRANSFORM_DELIMITER = ":";
var TRANSFORM_DELIMITER = ",";
var TRANSFORM_KEY_VALUE_DELIMITER = "-";
var transformationUtils = {
  getDefault: function getDefault() {
    return DEFAULT_TRANSFORMATION_POSITION;
  },
  addAsQueryParameter: function addAsQueryParameter(options) {
    return options.transformationPosition === QUERY_TRANSFORMATION_POSITION;
  },
  validParameters: function validParameters(options) {
    if (typeof options.transformationPosition == "undefined") return false;
    return VALID_TRANSFORMATION_POSITIONS.indexOf(options.transformationPosition) != -1;
  },
  getTransformKey: function getTransformKey(transform) {
    if (!transform) {
      return "";
    }
    return supportedTransforms[transform] || supportedTransforms[transform.toLowerCase()] || "";
  },
  getChainTransformDelimiter: function getChainTransformDelimiter() {
    return CHAIN_TRANSFORM_DELIMITER;
  },
  getTransformDelimiter: function getTransformDelimiter() {
    return TRANSFORM_DELIMITER;
  },
  getTransformKeyValueDelimiter: function getTransformKeyValueDelimiter() {
    return TRANSFORM_KEY_VALUE_DELIMITER;
  }
};
var safeBtoa = function safeBtoa(str) {
  if (typeof window !== "undefined") {
    return btoa(str);
  } else {
    return Buffer.from(str, "utf8").toString("base64");
  }
};

var TRANSFORMATION_PARAMETER = "tr";
var SIMPLE_OVERLAY_PATH_REGEX = new RegExp('^[a-zA-Z0-9-._/ ]*$');
var SIMPLE_OVERLAY_TEXT_REGEX = new RegExp('^[a-zA-Z0-9-._ ]*$');
function removeTrailingSlash(str) {
  if (typeof str == "string" && str[str.length - 1] == "/") {
    str = str.substring(0, str.length - 1);
  }
  return str;
}
function removeLeadingSlash(str) {
  if (typeof str == "string" && str[0] == "/") {
    str = str.slice(1);
  }
  return str;
}
function pathJoin(parts, sep) {
  var separator = sep || "/";
  var replace = new RegExp(separator + "{1,}", "g");
  return parts.join(separator).replace(replace, separator);
}
var buildURL = function buildURL(opts) {
  if (!opts.path && !opts.src) {
    return "";
  }
  var urlObj, isSrcParameterUsedForURL, urlEndpointPattern;
  try {
    if (opts.path) {
      urlEndpointPattern = new URL(opts.urlEndpoint).pathname;
      urlObj = new URL(pathJoin([opts.urlEndpoint.replace(urlEndpointPattern, ""), opts.path]));
    } else {
      urlObj = new URL(opts.src);
      isSrcParameterUsedForURL = true;
    }
  } catch (e) {
    console.error(e);
    return "";
  }
  for (var i in opts.queryParameters) {
    urlObj.searchParams.append(i, String(opts.queryParameters[i]));
  }
  var transformationString = constructTransformationString(opts.transformation);
  if (transformationString && transformationString.length) {
    if (!transformationUtils.addAsQueryParameter(opts) && !isSrcParameterUsedForURL) {
      urlObj.pathname = pathJoin([TRANSFORMATION_PARAMETER + transformationUtils.getChainTransformDelimiter() + transformationString, urlObj.pathname]);
    }
  }
  if (urlEndpointPattern) {
    urlObj.pathname = pathJoin([urlEndpointPattern, urlObj.pathname]);
  } else {
    urlObj.pathname = pathJoin([urlObj.pathname]);
  }
  if (transformationString && transformationString.length) {
    if (transformationUtils.addAsQueryParameter(opts) || isSrcParameterUsedForURL) {
      if (urlObj.searchParams.toString() !== "") {
        return "".concat(urlObj.href, "&").concat(TRANSFORMATION_PARAMETER, "=").concat(transformationString);
      } else {
        return "".concat(urlObj.href, "?").concat(TRANSFORMATION_PARAMETER, "=").concat(transformationString);
      }
    }
  }
  return urlObj.href;
};
function processInputPath(str, enccoding) {
  str = removeTrailingSlash(removeLeadingSlash(str));
  if (enccoding === "plain") {
    return "i-".concat(str.replace(/\//g, "@@"));
  }
  if (enccoding === "base64") {
    return "ie-".concat(encodeURIComponent(safeBtoa(str)));
  }
  if (SIMPLE_OVERLAY_PATH_REGEX.test(str)) {
    return "i-".concat(str.replace(/\//g, "@@"));
  } else {
    return "ie-".concat(encodeURIComponent(safeBtoa(str)));
  }
}
function processText(str, enccoding) {
  if (enccoding === "plain") {
    return "i-".concat(encodeURIComponent(str));
  }
  if (enccoding === "base64") {
    return "ie-".concat(encodeURIComponent(safeBtoa(str)));
  }
  if (SIMPLE_OVERLAY_TEXT_REGEX.test(str)) {
    return "i-".concat(encodeURIComponent(str));
  }
  return "ie-".concat(encodeURIComponent(safeBtoa(str)));
}
function processOverlay(overlay) {
  var entries = [];
  if (!overlay) {
    return;
  }
  var type = overlay.type,
      _overlay$position = overlay.position,
      position = _overlay$position === void 0 ? {} : _overlay$position,
      _overlay$timing = overlay.timing,
      timing = _overlay$timing === void 0 ? {} : _overlay$timing,
      _overlay$transformati = overlay.transformation,
      transformation = _overlay$transformati === void 0 ? [] : _overlay$transformati;
  if (!type) {
    throw new Error("Overlay type is required");
  }
  switch (type) {
    case "text":
      {
        var textOverlay = overlay;
        if (!textOverlay.text) {
          return;
        }
        var enccoding = textOverlay.encoding || "auto";
        entries.push("l-text");
        entries.push(processText(textOverlay.text, enccoding));
      }
      break;
    case "image":
      entries.push("l-image");
      {
        var imageOverlay = overlay;
        var _enccoding = imageOverlay.encoding || "auto";
        if (imageOverlay.input) {
          entries.push(processInputPath(imageOverlay.input, _enccoding));
        } else {
          return;
        }
      }
      break;
    case "video":
      entries.push("l-video");
      {
        var videoOverlay = overlay;
        var _enccoding2 = videoOverlay.encoding || "auto";
        if (videoOverlay.input) {
          entries.push(processInputPath(videoOverlay.input, _enccoding2));
        } else {
          return;
        }
      }
      break;
    case "subtitle":
      entries.push("l-subtitle");
      {
        var subtitleOverlay = overlay;
        var _enccoding3 = subtitleOverlay.encoding || "auto";
        if (subtitleOverlay.input) {
          entries.push(processInputPath(subtitleOverlay.input, _enccoding3));
        } else {
          return;
        }
      }
      break;
    case "solidColor":
      entries.push("l-image");
      entries.push("i-ik_canvas");
      {
        var solidColorOverlay = overlay;
        if (solidColorOverlay.color) {
          entries.push("bg-".concat(solidColorOverlay.color));
        } else {
          return;
        }
      }
      break;
  }
  var x = position.x,
      y = position.y,
      focus = position.focus;
  if (x) {
    entries.push("lx-".concat(x));
  }
  if (y) {
    entries.push("ly-".concat(y));
  }
  if (focus) {
    entries.push("lfo-".concat(focus));
  }
  var start = timing.start,
      end = timing.end,
      duration = timing.duration;
  if (start) {
    entries.push("lso-".concat(start));
  }
  if (end) {
    entries.push("leo-".concat(end));
  }
  if (duration) {
    entries.push("ldu-".concat(duration));
  }
  var transformationString = constructTransformationString(transformation);
  if (transformationString && transformationString.trim() !== "") entries.push(transformationString);
  entries.push("l-end");
  return entries.join(transformationUtils.getTransformDelimiter());
}
function constructTransformationString(transformation) {
  if (!Array.isArray(transformation)) {
    return "";
  }
  var parsedTransforms = [];
  for (var i = 0, l = transformation.length; i < l; i++) {
    var parsedTransformStep = [];
    for (var key in transformation[i]) {
      var value = transformation[i][key];
      if (value === undefined || value === null) {
        continue;
      }
      if (key === "overlay" && _typeof(value) === "object") {
        var rawString = processOverlay(value);
        if (rawString && rawString.trim() !== "") {
          parsedTransformStep.push(rawString);
        }
        continue;
      }
      var transformKey = transformationUtils.getTransformKey(key);
      if (!transformKey) {
        transformKey = key;
      }
      if (transformKey === "") {
        continue;
      }
      if (["e-grayscale", "e-contrast", "e-removedotbg", "e-bgremove", "e-upscale", "e-retouch", "e-genvar"].includes(transformKey)) {
        if (value === true || value === "-" || value === "true") {
          parsedTransformStep.push(transformKey);
        } else {
          continue;
        }
      } else if (["e-sharpen", "e-shadow", "e-gradient", "e-usm", "e-dropshadow"].includes(transformKey) && (value.toString().trim() === "" || value === true || value === "true")) {
        parsedTransformStep.push(transformKey);
      } else if (key === "raw") {
        parsedTransformStep.push(transformation[i][key]);
      } else {
        if (transformKey === "di") {
          value = removeTrailingSlash(removeLeadingSlash(value || ""));
          value = value.replace(/\//g, "@@");
        }
        if (transformKey === "sr" && Array.isArray(value)) {
          value = value.join("_");
        }
        if (transformKey === "t" && value.toString().trim() === "") {
          value = "true";
        }
        parsedTransformStep.push([transformKey, value].join(transformationUtils.getTransformKeyValueDelimiter()));
      }
    }
    if (parsedTransformStep.length) {
      parsedTransforms.push(parsedTransformStep.join(transformationUtils.getTransformDelimiter()));
    }
  }
  return parsedTransforms.join(transformationUtils.getChainTransformDelimiter());
}

var url = function url(urlOpts, defaultOptions) {
  return buildURL(_objectSpread2(_objectSpread2({}, defaultOptions), urlOpts));
};

function mandatoryParametersAvailable(options) {
  return options.urlEndpoint;
}
var promisify = function promisify(thisContext, fn) {
  return function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    if (args.length === fn.length && typeof args[args.length - 1] !== "undefined") {
      if (typeof args[args.length - 1] !== "function") {
        throw new Error("Callback must be a function.");
      }
      fn.call.apply(fn, [thisContext].concat(args));
    } else {
      return new Promise(function (resolve, reject) {
        var callback = function callback(err) {
          if (err) {
            return reject(err);
          } else {
            for (var _len2 = arguments.length, results = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
              results[_key2 - 1] = arguments[_key2];
            }
            resolve(results.length > 1 ? results : results[0]);
          }
        };
        args.pop();
        args.push(callback);
        fn.call.apply(fn, [thisContext].concat(args));
      });
    }
  };
};
var ImageKit = function () {
  function ImageKit(opts) {
    _classCallCheck(this, ImageKit);
    _defineProperty(this, "options", {
      publicKey: "",
      urlEndpoint: "",
      transformationPosition: transformationUtils.getDefault()
    });
    this.options = _objectSpread2(_objectSpread2({}, this.options), opts || {});
    if (!mandatoryParametersAvailable(this.options)) {
      throw errorMessages.MANDATORY_INITIALIZATION_MISSING;
    }
    if (!transformationUtils.validParameters(this.options)) {
      throw errorMessages.INVALID_TRANSFORMATION_POSITION;
    }
  }
  _createClass(ImageKit, [{
    key: "url",
    value: function url$1(urlOptions) {
      return url(urlOptions, this.options);
    }
  }, {
    key: "upload",
    value: function upload$1(uploadOptions, callbackOrOptions, options) {
      var callback;
      if (typeof callbackOrOptions === 'function') {
        callback = callbackOrOptions;
      } else {
        options = callbackOrOptions || {};
      }
      if (!uploadOptions || _typeof(uploadOptions) !== "object") {
        return respond(true, errorMessages.INVALID_UPLOAD_OPTIONS, callback);
      }
      var mergedOptions = _objectSpread2(_objectSpread2({}, this.options), options);
      var _ref = uploadOptions || {},
          userProvidedXHR = _ref.xhr;
      delete uploadOptions.xhr;
      var xhr = userProvidedXHR || new XMLHttpRequest();
      return promisify(this, upload)(xhr, uploadOptions, mergedOptions, callback);
    }
  }]);
  return ImageKit;
}();

export default ImageKit;