How to use promise-polyfill - 10 common examples

function getDataFromTree(rootElement, rootContext, fetchRoot, mergeProps, isTopLevel){

  //console.log(`Now searching element (${rootElement.type.name || rootElement.type.displayName}):`, rootElement);

  // Get array of queries (fetchData promises) from tree
  // This will traverse down recursively looking for fetchData() methods
  let queries = getQueriesFromTree(rootElement, rootContext, fetchRoot, mergeProps);

  // No queries found. We're done!
  if (!queries.length) {
    return Promise.resolve();
  }

  // We've traversed down as far as possible in thecurrent tree branch ...
  // Wait on each query that we found, re-rendering the subtree when it's done.
  const mappedQueries = queries.map(({ query, element, context }) =>  {
    return query.then((newProps) => {
      const displayName = element.type.displayName;

      if (!displayName){
        // TODO: Use Promise.reject and catch()
        throw new Error('[React Component Data] When resolving component data recursively each component must have a displayName set.');
      }

      // Add to finalData array that will be returned
      finalData[displayName] = newProps;
      // Traverse children

export function init(configUpdates) {
	config.update(configUpdates);
	log.debug('Using configuration:', config);
	const startTime = Date.now();

	// Fetch the current vendor consent before initializing
	return Promise.all([
		readVendorConsentCookie(),
		fetchPubVendorList()
	])
		.then(([vendorConsentData, pubVendorsList]) => {
			const {vendors} = pubVendorsList || {};

			// Check config for allowedVendorIds then the pubVendorList
			const {allowedVendorIds: configVendorIds} = config;
			const allowedVendorIds = configVendorIds instanceof Array && configVendorIds.length ? configVendorIds :
				vendors && vendors.map(vendor => vendor.id);

			// Initialize the store with all of our consent data
			const store = new Store({
				cmpVersion: CMP_VERSION,
				cmpId: CMP_ID,
				cookieVersion: COOKIE_VERSION,

const name = (root.getAttribute('is') || root.tagName).toLowerCase();
      promises.push(window.customElements.whenDefined(name));
    }
    
    // Check all descending elements
    for (let i = 0; i < elements.length; i++) {
      const el = elements[i];
      if (!el._componentReady) {
        const name = (el.getAttribute('is') || el.tagName).toLowerCase();
        promises.push(window.customElements.whenDefined(name));
      }
    }
    
    // Call callback once all defined
    if (promises.length) {
      Promise.all(promises)
        .then(() => {
          onDefined(element instanceof HTMLElement && element || window);
        })
        .catch((err) => {
          console.error(err);
        });
    }
    else {
      // Call callback by default if all defined already
      onDefined(element instanceof HTMLElement && element || window);
    }
  }

Dropbox.prototype.addTemplate = function (path) {

    if (!path) {
        return Promise.reject(null);
    }

    const ext = extname(path);
    if (!(ext in Template.Parsers)) {
        return Promise.reject(
            new Error(`Incorrect extension ${ext} for template`)
        );
    }

    return this.download(path).then((data) => {
         const tmpl = Template.Parsers[ext](data);
         const name = basename(path, true).split('_').pop();

         // Avoid duplicates
         let uniqueName = name, i = 1;
         while (uniqueName in this._templates) {
             uniqueName = `${name}-${i}`;
             i++;
         }

         this._templates[uniqueName] = tmpl;

export function ImagePromise (url, auth=false) {

    return new Promise(function (resolve, reject) {

        var xhr = new XMLHttpRequest();

        xhr.open('GET', url, true);
        xhr.responseType = 'blob';
        var img = new Image();

        xhr.withCredentials = !!auth;
        var asyncId = loading.start();

        xhr.addEventListener('load', function () {
            if (this.status === 200) {
                var blob = this.response;
                img.addEventListener('load', function () {
                    loading.stop(asyncId);
                    window.URL.revokeObjectURL(img.src); // Clean up after ourselves.

async signin(email) {
    // Sign in to the server
    return new Promise(async (resolve, reject) => {
      if (typeof window === 'undefined') {
        return reject(Error('This method should only be called on the client'))
      }

      // Make sure we have session in memory
      this._session = await this.getSession()

      // Make sure we have the latest CSRF Token in our session
      this._session.csrfToken = await Session.getCsrfToken()

      let xhr = new window.XMLHttpRequest()
      xhr.open('POST', '/auth/email/signin', true)
      xhr.setRequestHeader('Content-type', 'application/x-www-form-urlencoded')
      xhr.onreadystatechange = () => {
        if (xhr.readyState === 4) {
          if (xhr.status !== 200) {

export default function XMLHttpRequestPromise(
    url, {
        method='GET',
        responseType,
        contentType,
        headers={},
        data,
        auth=false
    }
){
    var xhr = new XMLHttpRequest();
    xhr.open(method, url);
    // Return a new promise.
    var promise = new Promise(function(resolve, reject) {
        // Do the usual XHR stuff
        xhr.responseType = responseType || 'text';
        var asyncId = loading.start();

        xhr.withCredentials = !!auth;

        Object.keys(headers).forEach(function (key) {
            xhr.setRequestHeader(key, headers[key]);
        });

        if (contentType) {
            xhr.setRequestHeader('Content-Type', contentType);
        }

        xhr.onload = function() {
            // This is called even on 404 etc

// Notify listeners that the CMP is loaded
			log.debug(`Successfully loaded CMP version: ${pack.version} in ${Date.now() - startTime}ms`);
			cmp.isLoaded = true;
			cmp.notify('isLoaded');

			// Render the UI
			const App = require('../components/app').default;
			render(, document.body);


			// Execute any previously queued command
			cmp.commandQueue = commandQueue;
			cmp.processCommandQueue();

			// Request lists
			return Promise.all([
				fetchGlobalVendorList().then(store.updateVendorList),
				fetchPurposeList().then(store.updateCustomPurposeList)
			]).then(() => {
				cmp.cmpReady = true;
				cmp.notify('cmpReady');
			}).catch(err => {
				log.error('Failed to load lists. CMP not ready', err);
			});
		})
		.catch(err => {

const displayName = element.type.displayName;

      if (!displayName){
        // TODO: Use Promise.reject and catch()
        throw new Error('[React Component Data] When resolving component data recursively each component must have a displayName set.');
      }

      // Add to finalData array that will be returned
      finalData[displayName] = newProps;
      // Traverse children
      // Component will use newProps returned by the query so we can find any children it might have as a result
      return getDataFromTree(element, context, false, newProps);
    })
  });

  return Promise.all(mappedQueries).then((values) => {
    // Only return final data at top level
    // Not inside recursive getDataFromTree calls
    if (isTopLevel){
      return finalData;
    }
  });
}

return Promise.reject(exc);
    }
  } catch (error) {
    log.warn(error);
  }
  // Use extra transport - img
  // Send only part when using gif
  const smallMsg = (msg.service === SERVICE_TRACK)
    ? this.options.msgCropper(msg) : msg;
  log(`sending using IMG. useSafe: ${useSafe}`, smallMsg);

  try {
    return this.sendIMG(this.makeURL(imgPath, objectAssign(smallMsg, this.creds)));
  } catch (e) {
    log('Error during sending data using image', e);
    return Promise.reject(e);
  }
};