Source: review.js

  1. /* global $, config, libreviews */
  2. /* eslint prefer-reflect: "off" */
  3. /**
  4.  * Immediately invoked function expression that initializes various event
  5.  * handlers that are part of the review form, including:
  6.  * - management of client-side drafts
  7.  * - "star rating" selector
  8.  * - mode switcher for source selection and integration with lookup adapters
  9.  *
  10.  * @namespace Review
  11.  */
  12. (function() {
  14.   'use strict';
  16.   require('es6-promise').polyfill();
  18.   const NativeLookupAdapter = require('./adapters/native-lookup-adapter');
  19.   const OpenStreetMapLookupAdapter = require('./adapters/openstreetmap-lookup-adapter');
  20.   const WikidataAutocompleteAdapter = require('./adapters/wikidata-autocomplete-adapter');
  21.   const OpenLibraryAutocompleteAdapter = require('./adapters/openlibrary-autocomplete-adapter');
  23.   // All adapters will be tried against a provided review subject URL. If they
  24.   // support it, they will perform a parallel, asynchronous lookup. The array order
  25.   // matters in that the first element in the array (not the first to return
  26.   // a result) will be used for the review subject metadata. The native (lib.reviews)
  27.   // lookup therefore always takes precedence.
  28.   const adapters = [
  29.     new NativeLookupAdapter(),
  30.     new OpenStreetMapLookupAdapter(),
  31.     new WikidataAutocompleteAdapter(updateURLAndReviewSubject, '#review-search-database'),
  32.     new OpenLibraryAutocompleteAdapter(updateURLAndReviewSubject, '#review-search-database')
  33.   ];
  35.   /**
  36.    * URL of the most recently used lookup from an adapter.
  37.    *
  38.    * @type {String}
  39.    * @memberof Review
  40.    */
  41.   let lastLookup;
  43.   /**
  44.    * Most recently selected adapter.
  45.    *
  46.    * @type {Object}
  47.    * @memberof Review
  48.    */
  49.   let lastAdapter;
  51.   // Our form's behavior depends significantly on whether we're creating
  52.   // a new review, or editing an old one.
  53.   let editing = config.editing;
  54.   let textFields = editing ? '#review-title,#review-text' :
  55.     '#review-url,#review-title,#review-text';
  57.   /**
  58.    * Holds instance of external library for client-side storage of new reviews
  59.    * in progress.
  60.    *
  61.    * @memberof Review
  62.    */
  63.   let sisyphus;
  65.   // Add inputs used only with JS here so they don't appear/conflict when JS is disabled
  66.   $('#star-rating-control').append(`<input id="review-rating" name="review-rating" type="hidden" data-required>`);
  68.   /**
  69.    * Rating value of previous POST request, if any.
  70.    *
  71.    * @memberof Review
  72.    */
  73.   let postRating = $('#star-rating-control').attr('data-post') || '';
  75.   // Register event handlers
  77.   $('[id^=star-button-]')
  78.     .mouseout(clearStars)
  79.     .mouseover(indicateStar)
  80.     .click(selectStar)
  81.     .keyup(maybeSelectStar);
  83.   // Little "X" icon that makes previously looked up information from Wikidata
  84.   // and other sources go away and clears out the URL field
  85.   $('#remove-resolved-info')
  86.     .click(removeResolvedInfo)
  87.     .keyup(maybeRemoveResolvedInfo);
  89.   // Highlight rating from POST request
  90.   if (postRating)
  91.     selectStar.apply($(`#star-button-${postRating}`)[0]);
  93.   // We only have to worry about review subject lookup for new reviews,
  94.   // not when editing existing reviews
  95.   if (!editing) {
  96.     initializeURLValidation();
  97.     $(textFields).change(hideAbandonDraft);
  98.     $('#review-url').keyup(function(event) {
  99.       handleURLLookup.call(this, event, true); // Suppresses modal while typing
  100.     });
  101.     $('#review-url').keyup(handleURLFixes);
  102.     $('#review-url').change(handleURLLookup);
  103.     $('#review-url').change(handleURLValidation);
  104.     $('#dismiss-draft-notice').click(hideDraftNotice);
  105.     $('#abandon-draft').click(emptyAllFormFields);
  106.     $('#add-http').click(addHTTP);
  107.     $('#add-https').click(addHTTPS);
  109.     // When writing a review of an existing thing, the URL field is not
  110.     // available, so do not attempt to store data to it.
  111.     let maybeExcludeURL = '';
  112.     if (!$('#review-url').length)
  113.       maybeExcludeURL = ',#review-url';
  115.     // Persist form in local storage
  116.     sisyphus = $('#review-form').sisyphus({
  117.       onBeforeRestore: restoreDynamicFields,
  118.       onRestore: processLoadedData,
  119.       excludeFields: $('[data-ignore-autosave]' + maybeExcludeURL)
  120.     });
  122.     // Wire up mode switcher for source of review subject: URL or database
  123.     $('#review-via-url').conditionalSwitcherClick(activateReviewViaURL);
  124.     $('#review-via-database').conditionalSwitcherClick(activateReviewViaDatabase);
  126.     // Wire up source selector dropdown for "review via database" workflow
  127.     $('#source-selector-dropdown').change(selectSource);
  129.     // Bubbling interferes with autocomplete's window-level click listener
  130.     $('#source-selector-dropdown').click(function(event) {
  131.       event.stopPropagation();
  132.     });
  134.     // Initialize search autocomplete for currently selected source
  135.     selectSource.apply($('#source-selector-dropdown')[0]);
  136.   }
  138.   // In case we're in preview mode and have a URL, make sure we fire the URL
  139.   // validation/lookup handlers
  140.   if ($('#preview-contents').length && $('#review-url').val()) {
  141.     handleURLLookup.apply($('#review-url')[0]);
  142.     handleURLValidation.apply($('#review-url')[0]);
  143.   }
  145.   /**
  146.    * Hide information indicating that an unsaved draft is available.
  147.    *
  148.    * @memberof Review
  149.    */
  150.   function hideDraftNotice() {
  151.     if ($('#draft-notice').is(':visible'))
  152.       $('#draft-notice').fadeOut(200);
  153.   }
  155.   /**
  156.    * Remove a previously resolved review subject from a review.
  157.    *
  158.    * @memberof Review
  159.    */
  160.   function removeResolvedInfo() {
  161.     clearResolvedInfo();
  162.     $('#review-url').val('');
  163.     // Trigger change-related event handlers
  164.     handleURLLookup.apply($('#review-url')[0]);
  165.     handleURLValidation.apply($('#review-url')[0]);
  166.     // Update saved data w/ empty URL
  167.     sisyphus.saveAllData();
  169.     // Focus back on URL field.
  170.     // We don't clear out any search fields in case the user quickly wants
  171.     // to get back to the text they previously entered.
  172.     $('#review-via-url').click();
  173.   }
  175.   /**
  176.    * Keyboard handler that triggers {@link Review.removeResolvedInfo}
  177.    * on `[Enter]` and `[Space]`.
  178.    *
  179.    * @memberof Review
  180.    */
  181.   function maybeRemoveResolvedInfo() {
  182.     if (event.keyCode == 13 || event.keyCode == 32)
  183.       removeResolvedInfo();
  184.   }
  186.   /**
  187.    * Hide the option for abandoning a draft once the user has started editing
  188.    * it.
  189.    *
  190.    * @memberof Review
  191.    */
  192.   function hideAbandonDraft() {
  193.     if ($('#abandon-draft').is(':visible'))
  194.       $('#abandon-draft').fadeOut(200);
  195.   }
  197.   /**
  198.    * Add a HTTP or HTTPS prefix to the review URL.
  199.    * @param {String} protocol - "http" or "https"
  200.    *
  201.    * @memberof Review
  202.    */
  203.   function addProtocol(protocol) {
  204.     $('#review-url').val(protocol + '://' + $('#review-url').val());
  205.     $('#review-url').trigger('change');
  206.   }
  208.   /**
  209.    * Add HTTP prefix to the review URL field and focus on it.
  210.    * @param {Event} event the click event on the "Add HTTP" link
  211.    *
  212.    * @memberof Review
  213.    */
  214.   function addHTTP(event) {
  215.     addProtocol('http');
  216.     $('#review-label').focus();
  217.     event.preventDefault();
  218.   }
  220.   /**
  221.    * Add HTTPS prefix to the review URL field and focus on it.
  222.    * @param {Event} event the click event on the "Add HTTPS" link
  223.    *
  224.    * @memberof Review
  225.    */
  226.   function addHTTPS(event) {
  227.     addProtocol('https');
  228.     $('#review-label').focus();
  229.     event.preventDefault();
  230.   }
  232.   /**
  233.    * Ask all available adapters for information about the currently provided
  234.    * URL, via asynchronous lookup. Note this is separate from the search
  235.    * option -- we look up information, e.g., from Wikidata even if the user just
  236.    * puts in a Wikidata URL.
  237.    *
  238.    * @param {Event} [_event]
  239.    *  the event that triggered the lookup; not used
  240.    * @param {Boolean} [suppressModal=false]
  241.    *  Suppress the modal shown if the user has previously reviewed this subject.
  242.    *  Overkill while typing, so suppressed there.
  243.    *
  244.    * @memberof Review
  245.    */
  246.   function handleURLLookup(_event, suppressModal) {
  247.     let inputEle = this;
  248.     let inputURL = inputEle.value;
  249.     let promises = [];
  251.     // Avoid duplicate lookups on keyup
  252.     if (inputURL === lastLookup)
  253.       return;
  255.     // Track lookups, regardless of success or failure
  256.     lastLookup = inputURL;
  258.     if (!inputURL) {
  259.       clearResolvedInfo();
  260.       return;
  261.     }
  263.     // We look up this URL using all adapters that support it. The native
  264.     // adapter performs its own URL schema validation, and other adapters
  265.     // are more restrictive.
  266.     adapters.forEach(adapter => {
  267.       if (adapter.ask && adapter.lookup && adapter.ask(inputURL))
  268.         promises.push(adapter.lookup(inputURL));
  269.     });
  271.     // We use a mapped array so we can catch failing promises and pass along
  272.     // the error as payload, instead of aborting the whole process if even
  273.     // one of the queries fails.
  274.     Promise
  275.       .all(promises.map(promise => promise.catch(error => ({ error }))))
  276.       .then(results => {
  277.         // If the URL field has been cleared since the user started the query,
  278.         // don't bother with the result of the lookup
  279.         if (!inputEle.value)
  280.           return;
  281.         // Use first valid result in order of the array. Since the native lookup
  282.         // is the first array element, it will take precedence over any adapters.
  283.         for (let result of results) {
  284.           if (result.data && result.data.label) {
  286.             // User has previously reviewed this subject
  287.             if (result.data.thing && typeof result.data.thing.reviews == 'object' &&
  288.               result.data.thing.reviews.length) {
  289.               if (!suppressModal) {
  290.                 showModalForEditingExistingReview(result.data);
  291.                 return;
  292.               } else {
  293.                 // Don't show modal - perhaps user is still typing.
  294.                 // May have to show modal later, so don't cache lookup
  295.                 lastLookup = undefined;
  296.               }
  297.             }
  298.             updateReviewSubject({
  299.               url: inputURL,
  300.               label: result.data.label,
  301.               description: result.data.description, // may be undefined
  302.               subtitle: result.data.subtitle,
  303.               thing: result.data.thing // may be undefined
  304.             });
  305.             return;
  306.           }
  307.           clearResolvedInfo();
  308.         }
  309.       });
  310.   }
  312.   /**
  313.    * Show modal that asks the user to edit an existing review of the given
  314.    * subject, or to pick another review subject.
  315.    *
  316.    * @param {Object} data
  317.    *  data used for the redirect
  318.    * @param {Object[]} data.reviews
  319.    *  array of reviews by the current user for this thing. Under normal
  320.    *  circumstances there should only be 1, but this is not a hard constraint
  321.    *  at the database level.
  322.    */
  323.   function showModalForEditingExistingReview(data) {
  324.     const $modal = $(`<div class="hidden-regular" id="review-modal"></div>`)
  325.       .append('<p>' + window.libreviews.msg('previously reviewed') + '</p>')
  326.       .append('<p><b>' + data.label + '</b></p>')
  327.       .append('<p>' + window.libreviews.msg('abandon form changes') + '</p>')
  328.       .append('<button class="pure-button pure-button-primary button-rounded" id="edit-existing-review">' +
  329.         window.libreviews.msg('edit review') + '</button>')
  330.       .append('&nbsp;<a href="#" id="pick-different-subject">' + window.libreviews.msg('pick a different subject') + '</a>');
  331.     $modal.insertAfter('#review-subject');
  332.     $modal.modal({
  333.       escapeClose: false,
  334.       clickClose: false,
  335.       showClose: false
  336.     });
  337.     $('#edit-existing-review').click(() => {
  338.       // Clear draft
  339.       sisyphus.manuallyReleaseData();
  340.       window.location.assign(`/review/${data.thing.reviews[0].id}/edit`);
  341.     });
  342.     $('#pick-different-subject').click(event => {
  343.       $.modal.close();
  344.       $modal.remove();
  345.       $('#review-url').val('');
  346.       $('#review-url').trigger('change');
  347.       event.preventDefault();
  348.     });
  349.     $modal.lockTab();
  350.   }
  352.   /**
  353.    * Clean out any old URL metadata and show the label field again
  354.    *
  355.    * @memberof Review
  356.    */
  357.   function clearResolvedInfo() {
  358.     $('.resolved-info').empty();
  359.     $('#review-subject').hide();
  360.     $('.review-label-group').show();
  361.     window.libreviews.repaintFocusedHelp();
  362.   }
  364.   /**
  365.    * Show warning and helper links as appropriate for a given subject URL.
  366.    *
  367.    * @memberof Review
  368.    */
  369.   function handleURLValidation() {
  370.     let inputURL = this.value;
  372.     if (inputURL && !libreviews.validateURL(inputURL)) {
  373.       $('#review-url-error').show();
  374.       if (!libreviews.urlHasSupportedProtocol(inputURL)) {
  375.         $('.helper-links').show();
  376.         $('#add-https').focus();
  377.       } else {
  378.         $('.helper-links').hide();
  379.       }
  380.     } else {
  381.       $('#review-url-error').hide();
  382.       $('.helper-links').hide();
  383.     }
  384.   }
  387.   /**
  388.    * Update UI based on URL corrections of validation problems. This is
  389.    * registered on keyup for the URL input field, so corrections are instantly
  390.    * detected.
  391.    *
  392.    * @memberof Review
  393.    */
  394.   function handleURLFixes() {
  395.     let inputURL = this.value;
  396.     if ($('#review-url-error').is(':visible')) {
  397.       if (libreviews.validateURL(inputURL)) {
  398.         $('#review-url-error').hide();
  399.         $('.helper-links').hide();
  400.       }
  401.     }
  402.   }
  404.   /**
  405.    * Callback called from adapters for adding informationed obtained via an
  406.    * adapter to the form. Except for the URL, the information is not actually
  407.    * associated with the review, since the corresponding server-side adapter
  408.    * will perform its own deep lookup.
  409.    *
  410.    * @param {Object} data - Data obtained by the adapter
  411.    * @memberof Review
  412.    */
  413.   function updateURLAndReviewSubject(data) {
  414.     if (!data.url)
  415.       throw new Error('To update a URL, we must get one.');
  416.     $('#review-url').val(data.url);
  418.     // Re-validate URL. There shouldn't be any problems with the new URL, so
  419.     // this will mainly clear out old validation errors.
  420.     handleURLValidation.apply($('#review-url')[0]);
  422.     // If user has previously reviewed this, they need to choose to pick a
  423.     // different subject or to edit their existing review
  424.     if (data.thing && data.thing.reviews) {
  425.       // Previous adapter may have loaded info
  426.       clearResolvedInfo();
  427.       showModalForEditingExistingReview(data);
  428.       return;
  429.     }
  431.     updateReviewSubject(data);
  432.     // Make sure we save draft in case user aborts here
  433.     sisyphus.saveAllData();
  434.   }
  436.   /**
  437.    * Handle the non-URL information obtained via the
  438.    * {@link Review.updateURLAndReviewSubject} callback, or via the
  439.    * {@link Review.handleURLLookup} handler on the URL input field.
  440.    *
  441.    * @param {Object} data - Data obtained by the adapter
  442.    * @memberof Review
  443.    */
  444.   function updateReviewSubject(data) {
  445.     const { url, label, description, subtitle, thing } = data;
  446.     if (!label)
  447.       throw new Error('Review subject must have a label.');
  448.     let wasFocused = $('#resolved-url a').is(':focus');
  449.     $('.resolved-info').empty();
  450.     $('#resolved-url').append(`<a href="${url}" target="_blank">${label}</a>`);
  451.     if (description)
  452.       $('#resolved-description').html(description);
  453.     if (subtitle)
  454.       $('#resolved-subtitle').html(`<i>${subtitle}</i>`);
  456.     if (thing) {
  457.       $('#resolved-thing').append(`<a href="/${thing.urlID}" target="_blank">${libreviews.msg('more info')}</a>`);
  458.     }
  459.     $('#review-subject').show();
  460.     if (wasFocused)
  461.       $('#resolved-url a').focus();
  462.     $('.review-label-group').hide();
  463.     // We don't want to submit previously entered label data
  464.     $('#review-label').val('');
  465.     // If now hidden field is focused, focus on title field instead (next in form)
  466.     if ($('#review-label').is(':focus') || document.activeElement === document.body)
  467.       $('#review-title').focus();
  468.   }
  471.   /**
  472.    * Clear out old draft
  473.    *
  474.    * @param {Event} event - click event from the "Clear draft" button
  475.    * @memberof Review
  476.    */
  477.   function emptyAllFormFields(event) {
  478.     clearStars();
  479.     $('#review-url,#review-title,#review-text,#review-rating').val('');
  480.     $('#review-url').trigger('change');
  481.     for (let rte in window.libreviews.activeRTEs)
  482.       window.libreviews.activeRTEs[rte].reRender();
  483.     sisyphus.manuallyReleaseData();
  484.     hideDraftNotice();
  485.     event.preventDefault();
  486.   }
  489.   /**
  490.    * Restore fields that were dynamically added by JavaScript and not part of
  491.    * the original form.
  492.    *
  493.    * @memberof Review
  494.    */
  495.   function restoreDynamicFields() {
  496.     const uploadRegex = /^\[id=review-form\].*\[name=(uploaded-file-.*?)\]$/;
  497.     for (let key in localStorage) {
  498.       if (uploadRegex.test(key)) {
  499.         const fieldName = key.match(uploadRegex)[1];
  500.         $('#review-form').append(`<input type="hidden" name="${fieldName}">`);
  501.       }
  502.     }
  503.   }
  505.   /**
  506.    * Load draft data into the review form.
  507.    *
  508.    * @memberof Review
  509.    */
  510.   function processLoadedData() {
  511.     let rating = Number($('#review-rating').val());
  513.     // Trim just in case whitespace got persisted
  514.     $('input[data-auto-trim],textarea[data-auto-trim]').each(window.libreviews.trimInput);
  516.     // Only show notice if we've actually recovered some data
  517.     if (rating || $('#review-url').val() || $('#review-title').val() || $('#review-text').val()) {
  518.       if (rating)
  519.         selectStar.apply($(`#star-button-${rating}`)[0]);
  521.       $('#draft-notice').show();
  522.       // Repaint help in case it got pushed down
  523.       window.libreviews.repaintFocusedHelp();
  524.     }
  526.     // Show URL issues if appropriate
  527.     if ($('#review-url').length) {
  528.       handleURLLookup.apply($('#review-url')[0]);
  529.       handleURLValidation.apply($('#review-url')[0]);
  530.     }
  531.   }
  534.   /**
  535.    * Replace star images with their placeholder versions
  536.    *
  537.    * @param {Number} start - rating from which to start clearing
  538.    * @memberof Review
  539.    */
  540.   function clearStars(start) {
  542.     if (!start || typeof start !== "number")
  543.       start = 1;
  544.     for (let i = start; i < 6; i++)
  545.       replaceStar(i, `/static/img/star-placeholder.svg`, 'star-holder');
  546.   }
  549.   /**
  550.    * replaceStar - Helper function to replace individual star image
  551.    *
  552.    * @param {Number} id - number of the star to replace
  553.    * @param {String} src - value for image source attribute
  554.    * @param {String} className - CSS class to assign to element
  555.    * @memberof Review
  556.    */
  557.   function replaceStar(id, src, className) {
  558.     $(`#star-button-${id}`)
  559.       .attr('src', src)
  560.       .removeClass()
  561.       .addClass(className);
  562.   }
  565.   /**
  566.    * Handler to restore star rating to a previously selected setting.
  567.    *
  568.    * @memberof Review
  569.    */
  570.   function restoreSelected() {
  571.     let selectedStar = $('#star-rating-control').attr('data-selected');
  572.     if (selectedStar)
  573.       selectStar.apply($(`#star-button-${selectedStar}`)[0]);
  574.   }
  576.   /**
  577.    * Handler to "preview" a star rating, used on mouseover.
  578.    *
  579.    * @returns {Number} - the number value of the selected star
  580.    * @memberof Review
  581.    */
  582.   function indicateStar() {
  583.     // We want to set all stars to the color of the selected star
  584.     let selectedStar = Number(this.id.match(/\d/)[0]);
  585.     for (let i = 1; i <= selectedStar; i++)
  586.       replaceStar(i, `/static/img/star-${selectedStar}-full.svg`, 'star-full');
  587.     if (selectedStar < 5)
  588.       clearStars(selectedStar + 1);
  589.     return selectedStar;
  590.   }
  593.   /**
  594.    * Key handler for selecting stars with `[Enter]` or `[Space]`.
  595.    *
  596.    * @param  {Event} event - the key event
  597.    */
  598.   function maybeSelectStar(event) {
  599.     if (event.keyCode == 13 || event.keyCode == 32)
  600.       selectStar.apply(this);
  601.   }
  603.   /**
  604.    * Actually apply a star rating.
  605.    *
  606.    * @memberof Review
  607.    */
  608.   function selectStar() {
  609.     let selectedStar = indicateStar.apply(this);
  610.     $('#star-rating-control').attr('data-selected', selectedStar);
  611.     $('#star-rating-control img[id^=star-button-]')
  612.       .off('mouseout')
  613.       .mouseout(restoreSelected);
  614.     $('#review-rating').val(selectedStar);
  615.     $('#review-rating').trigger('change');
  616.   }
  619.   /**
  620.    * Add template for URL validation errors, including "Add HTTP" and "Add HTTPS"
  621.    * helper links.
  622.    *
  623.    * @memberof Review
  624.    */
  625.   function initializeURLValidation() {
  626.     $('#url-validation').append(
  627.       `<div id="review-url-error" class="validation-error">${libreviews.msg('not a url')}</div>` +
  628.       `<div class="helper-links"><a href="#" id="add-https">${libreviews.msg('add https')}</a> &ndash; <a href="#" id="add-http">${libreviews.msg('add http')}</a></div>`
  629.     );
  630.   }
  632.   /**
  633.    * Click handler for activating the form for reviewing a subject by specifying
  634.    * a URL
  635.    *
  636.    * @memberof Review
  637.    */
  638.   function activateReviewViaURL() {
  639.     $('#review-via-database-inputs').addClass('hidden');
  640.     $('#review-via-url-inputs').removeClass('hidden');
  641.     $('.review-label-group').removeClass('hidden-regular');
  642.     $('#source-selector').toggleClass('hidden', true);
  643.     if (!$('#review-url').val())
  644.       $('#review-url').focus();
  645.   }
  648.   /**
  649.    * Click handler for activating the form for reviewing a subject by selecting
  650.    * it from an external database.
  651.    *
  652.    * @param  {Event} event - the click event
  653.    * @memberof Review
  654.    */
  655.   function activateReviewViaDatabase(event) {
  656.     // Does not conflict with other hide/show actions on this group
  657.     $('.review-label-group').addClass('hidden-regular');
  658.     $('#review-via-url-inputs').addClass('hidden');
  659.     $('#review-via-database-inputs').removeClass('hidden');
  660.     // Focusing pops the selection back up, so this check is extra important here
  661.     $('#source-selector').toggleClass('hidden', false);
  662.     if (!$('#review-search-database').val()) {
  663.       $('#review-search-database').focus();
  664.       // Ensure focus event to mount autocomplete widget is triggered
  665.       const focusEvent = new FocusEvent('focus', {
  666.         view: window,
  667.         bubbles: false,
  668.         cancelable: true
  669.       });
  670.       $('#review-search-database')[0].dispatchEvent(focusEvent);
  671.     }
  672.     // Suppress event bubbling up to window, which the AC widget listens to, and
  673.     // which would unmount the autocomplete function
  674.     event.stopPropagation();
  675.   }
  678.   /**
  679.    * Handler for selecting a source from the "database sources" dropdown,
  680.    * which requires lookup using an adapter plugin.
  681.    *
  682.    * @memberof Review
  683.    */
  684.   function selectSource() {
  685.     let sourceID = $(this).val();
  687.     let adapter;
  688.     // Locate adapter responsible for source declared in dropdown
  689.     for (let a of adapters) {
  690.       if (a.getSourceID() == sourceID) {
  691.         adapter = a;
  692.         break;
  693.       }
  694.     }
  696.     if (lastAdapter && lastAdapter.removeAutocomplete)
  697.       lastAdapter.removeAutocomplete();
  699.     if (adapter && adapter.setupAutocomplete) {
  700.       adapter.setupAutocomplete();
  701.       if (lastAdapter) {
  702.         // Re-run search, unless this is the first one. Sets focus on input.
  703.         if (adapter.runAutocomplete)
  704.           adapter.runAutocomplete();
  706.         // Change help text
  707.         $('#review-search-database-help .help-heading')
  708.           .html(libreviews.msg(`review via ${adapter.getSourceID()} help label`));
  710.         $('#review-search-database-help .help-paragraph')
  711.           .html(libreviews.msg(`review via ${adapter.getSourceID()} help text`));
  713.         // Change input placeholder
  714.         $('#review-search-database').attr('placeholder',
  715.           libreviews.msg(`start typing to search ${adapter.getSourceID()}`));
  717.         window.libreviews.repaintFocusedHelp();
  718.       }
  719.     }
  721.     // Track usage of the adapter so we can run functions on change
  722.     lastAdapter = adapter;
  723.   }
  725. }());