@suffolklitlab/alkiln 5.17.0 → 5.17.1

package/lib/scope.js

@@ -347,6 +347,7 @@ module.exports = {
         // This is meant to detect user-visible alerts/errors,
         // not breaking errors in the testing code.
         // No need for aborters since puppeteer has its own timeout
+        // TODO: Be more specific. Authors may use `.alert-danger` themselves.
         scope.page.waitForSelector('.alert-danger', { visible: true }),
         scope.page.waitForSelector('.da-has-error', { visible: true }),
       ]);
@@ -556,22 +557,56 @@ module.exports = {
     return false;
   },
 
-  continue_button_selector: `fieldset.da-field-buttons button[type="submit"].btn-primary`,
-  continue_button_selector_backup: `.da-fieldset.da-field-buttons button[type="submit"].btn-primary`,
-  signature_selector: `fieldset .dasigsave`,
-  signature_selector_backup: `.da-fieldset .dasigsave`,
+  continue_button_selector_da_v_1_9_n_and_earlier: `fieldset.da-field-buttons button[type="submit"].btn-primary`,
+  continue_button_selector_da_v_1_10_n_and_later: `button[type="submit"]#da-continue-button`,
+  continue_button_selector_backup_da_v_1_9_n_and_earlier: `.da-fieldset.da-field-buttons button[type="submit"].btn-primary`,
+  signature_cont_btn_selector_da_v_1_9_n_and_earlier: `fieldset .dasigsave`,
+
+  signature_cont_btn_selector_backup_da_v_1_9_n_and_earlier: `.da-fieldset .dasigsave`,
+  // ⚠️ docassemble >= 1.10.n, 2 signature page continue buttons. One visible on
+  //   wide screen, one visible on narrow screen. We need to get the visible
+  //   one, but puppeteer v22.15.0 doesn't recognize an element with a hidden
+  //   ancestor as invisible, so we need to get both `.dasigsave` and test for
+  //   visibility our own way for now.
+  signature_cont_btn_selector_da_v_1_10_n_and_later: `.dasigsave`,
   continue: async function ( scope ) {
-    /* Presses whatever button it finds that might lead to the next page. */
-    // Any selectors I find seem somewhat precarious.
-    let elem = await Promise.race([
-      scope.page.waitForSelector(scope.continue_button_selector),  // other pages (this is the most consistent way)
-      scope.page.waitForSelector(scope.continue_button_selector_backup),
-      scope.page.waitForSelector(scope.signature_selector),  // signature page
-      scope.page.waitForSelector(scope.signature_selector_backup),
-    ]);
-    await elem.evaluate( el => { return el.className });
+    /**
+     * Presses whatever button it finds that might lead to the next page.
+     * 
+     * @param {object} scope - Tests state object
+     * */
+    // ⚠️ Any selectors I find seem somewhat precarious.
+    let elem_lists = [
+      // non-signature pages (these are the most consistent ways)
+      await scope.page.$$(scope.continue_button_selector_da_v_1_9_n_and_earlier, { visible: true }),
+      await scope.page.$$(scope.continue_button_selector_da_v_1_10_n_and_later, { visible: true }),
+      await scope.page.$$(scope.continue_button_selector_backup_da_v_1_9_n_and_earlier, { visible: true }),
+      // signature pages
+      await scope.page.$$(scope.signature_cont_btn_selector_da_v_1_9_n_and_earlier, { visible: true }),
+      await scope.page.$$(scope.signature_cont_btn_selector_backup_da_v_1_9_n_and_earlier, { visible: true }),
+      // Two possible buttons if `visible: true` doesn't work
+      await scope.page.$$(scope.signature_cont_btn_selector_da_v_1_10_n_and_later, { visible: true }),
+    ];
+
+    // ⚠️ Avoid whichever `.dasigsave` button is hidden on signature screens. We
+    //   must do this ourselves because puppeteer v22.15.0 doesn't seem to
+    //   recognize when an ancestor of an element is `display: none`.
+    let continue_button = null;
+    for ( let possible_cont_buttons of elem_lists ) {
+      let found = false;
+      for ( let possible_cont_button of possible_cont_buttons ) {
+        let bounding_box = await possible_cont_button.boundingBox();
+        if ( bounding_box?.height !== 0 && bounding_box?.width !== 0) {
+          continue_button = possible_cont_button;
+          found = true;
+          break;
+        }
+      }
+      if ( found ) { break; }
+    }
+
     // Waits for navigation or user error
-    await scope.tapElementAndNavigate( scope, { elem });
+    await scope.tapElementAndNavigate( scope, { elem: continue_button });
   },  // Ends scope.continue()
 
   continue_exists: async function ( scope ) {
@@ -585,13 +620,18 @@ module.exports = {
     //   <button type="submit" class="btn btn-da btn-primary" name="Zm9v" value="True">Continue</button>
     // It will not find event screen `buttons:`, like an exit button or a restart button
     // <button type="submit" class="btn btn-da btn-danger" name="X211bHRpcGxlX2Nob2ljZQ" value="0">exit</button>
-    // `buttons:` can be used in question blocks as choices
-    let regular = await scope.page.$(scope.continue_button_selector);
-    let regular_backup = await scope.page.$(scope.continue_button_selector_backup);
-    let signature = await scope.page.$(scope.signature_selector);
-    let signature_backup = await scope.page.$(scope.signature_selector_backup);
+    // ⚠️ `buttons:` can be used in question blocks as choices
+
+    // Multiple matches not needed. We're just checking for presence.
+    let regular = await scope.page.$(scope.continue_button_selector_da_v_1_9_n_and_earlier, { visible: true });
+    let regular_da_v_1_10_x = await scope.page.$(scope.continue_button_selector_da_v_1_10_n_and_later, { visible: true });
+    let regular_backup = await scope.page.$(scope.continue_button_selector_backup_da_v_1_9_n_and_earlier, { visible: true });
 
-    return regular !== null || regular_backup !== null || signature !== null || signature_backup !== null;
+    let signature = await scope.page.$(scope.signature_cont_btn_selector_da_v_1_9_n_and_earlier, { visible: true });
+    let signature_backup = await scope.page.$(scope.signature_cont_btn_selector_backup_da_v_1_9_n_and_earlier, { visible: true });
+    let signature_da_v_1_10_x = await scope.page.$(scope.signature_cont_btn_selector_da_v_1_10_n_and_later, { visible: true });
+
+    return regular !== null || regular_da_v_1_10_x !== null || regular_backup !== null || signature !== null || signature_backup !== null || signature_da_v_1_10_x !== null;
 
   },  // Ends scope.continue_exists()
 
@@ -750,6 +790,14 @@ module.exports = {
   set_interview_session_data: function ( scope, { vars = null }) {
     /** Sets this interview's session data for this scenario if it doesn't
      *    already exist.
+     * 
+     * Discuss: Keep a record of insertion order of .interviews uids so we can
+     *   tell which interview is most recent and the order in which interviews
+     *   were visited.
+     * 
+     * TODO: If we don't already, when deleting interviews, use
+     *   scenario.interviews to get the relevant uids instead of just the most
+     *   recent uid? Multiple tests may be running.
      *
      * @returns final_vars { object | null }
      * @returns final_vars.i { str } File path of interview
@@ -931,8 +979,12 @@ module.exports = {
     *  as some kind of sophisticated data? With their selectors, for example.
     *  We will choose selectors that will continue to identify the node, eve
     *  after a hidden field is revealed, etc.
-    *  TODO: Not sure where to bring in cheerio
-    *  TODO: Pass in `$` instead? */
+    * 
+    * TODO: Not sure where to bring in cheerio. Pass in `$` instead?
+    * 
+    * TODO: Consider getting more data here so that other functionality can use
+    *   the data to reduce use of `page.evaluate()`.
+    * */
     let fields = [];
 
     const $ = cheerio.load( html );  // Could this be on `scope`?
@@ -960,55 +1012,87 @@ module.exports = {
     // Some `show if` fields have `names` like '_field_n' instead of their var name. Ex: _field_1
     let field_like_names = await scope.getFieldNamesDict( scope, { $: $ });
 
-    // All the different types of fields
-    // buttons, canvases, inputs of all kinds, selects (dropdowns), textareas. Are there more?
-    // Will deal with `option` once inside `select`
-    let all_nodes = $( `#dasigpage, fieldset button, .da-fieldset button, .daquestionactionbutton, fieldset input, da-fieldset input, .da-form-group input, .da-form-group select, form select, .da-form-group textarea` );
+    // All the different types of fields. Will deal with `option` once inside `select`
+
+    // All these hidden inputs moved inside the da form element. We want to keep
+    //   some hidden inputs, so we'll have to exclude the new neighbors.
+    let not = `:not([name="${ [
+      `_checkboxes`, `csrf_token`, `_event`, `_question_name`, `_tracker`, `_datatypes`, `_visible`, `_varnames`
+    ].join('"]):not([name="') }"])`;
+    let all_nodes = $(
+      `#dasigpage canvas`
+      + `, fieldset button, .da-fieldset button, .daquestionactionbutton, #daform button, #daform *[role="button"]`
+      + `, fieldset input${ not }, .da-fieldset input${ not }, .da-form-group input${ not }, #daform input${ not }`
+      + `, .da-form-group select, #daform select, #daform form select`
+      + `, .da-form-group textarea, #daform textarea`
+    );
+    let all_buttons = [];
+
+    // // TODO: When various versions of da resolve the `GET` errors, re-activate
+    // // this code out here instead of just for canvas elements.
+    // let question_data = await scope.get_question_data( scope );
+
     for ( let node of all_nodes ) {
-      // Decision: Do not abstract the below. There's too much data to pass around for it to make sense
       let $node = $( node );
       let field_data = {
         selector: '',
         tag: node.name,
-        guesses: [],
-        type: '',
+        guesses: null,
+        type: node.attribs.type || ``,
         trigger: trigger,
       };
-      if ( node.attribs.type ) { field_data.type = node.attribs.type; }
 
       // Often used for the variable name
-      let not_decoded_name = $node.attr( `name` );
-
-      // `<input type="hidden" name="_save_as" value="c2lnbmF0dXJlXzE">`
-      // canvas elements are the only field on a signature page
-      if ( $(`#dasigpage`).length > 0 && $(`#dasigpage`)[0].name ) {
-        field_data.selector = `#daquestion canvas`;
-        field_data.tag = `canvas`;
-
-        // If da server's config value of `restrict input variables`
-        // set to True, `_save_as` should work to get the var name
-        if ( $( `input[name="_save_as"]` ).length > 0 ) {
-          not_decoded_name = $( `input[name="_save_as"]` ).attr( `value` );
-
-        // If not, the author will have to use the trigger var HTML element
-        // or we can't get the var name being set for the signature
-        } else if ( trigger !== `` ) {
-          not_decoded_name = trigger;
-
-        // If we have neither of those, we need to tell the user we can't
-        // set this variable this way. We can't test this without a
-        // server that has that special config value set to `True`
-        } else {
+      let encoded_name = $node.attr( `name` );
+
+      if ( field_data.tag === `canvas` ) {  // $(`#dasigpage`).length > 0 && $(`#dasigpage`)[0].name ) {
+
+        let question_data = await scope.get_question_data( scope );
+
+        // ⚠️ Cheerio is unable to detect that some `.dasigsave` buttons are
+        //   hidden. Ignore buttons here. Take care of it with puppeteer later.
+
+        // Try for guesses that are most likely to be associated with the canvas
+        encoded_name ??= scope.canvas_name.try_for_best_encoded( scope, {
+          existing_guesses: field_data.guesses, $, trigger
+        });
+        if ( !encoded_name && !field_data.guesses ) {
+          field_data.guesses = scope.canvas_name.try_for_mid_guesses( scope, {
+            question_data
+          });
+        }
+
+        // Resort to names that may have proxy vars, such as x and i. See
+        //  docassemble generic objects and index vars. They are more
+        //  ambiguous since they could match multiple variables.
+
+        if ( !encoded_name && !field_data.guesses ) {
+          field_data.guesses = scope.canvas_name.try_for_worse_guesses( scope, {
+            question_data
+          });
+        }
+        if ( !encoded_name && !field_data.guesses ) {
+          encoded_name = scope.canvas_name.try_for_worse_encoded( scope, {
+            question_data
+          });
+        }
+        // ✏️ var_names handles an undefined encoded_name just fine
+
+        // If we have none of those, we need to tell the user we have too little
+        //   information to set the signature field variable We'll fail later
+        //   when we can take a proper screenshot.
+        if ( !field_data.guesses && !encoded_name ) {
           reports.addToReport(scope, {
             type: `error`,
             code: `ALK0123`,
-            value: `You cannot sign a signature page this way because the `
-              + `interview's HTML is missing data. Use the "I sign" Step `
-              + `instead. You can also read documentation about `
-              + `how to create the "trigger" HTML.`
+            value: `You cannot sign a signature page with this ALKiln Step `
+              + `because the interview's HTML is missing data. Use the "I sign" `
+              + `Step instead. You can also read documentation about `
+              + `how to add the "trigger" to the interview HTML.`
           });
+          // Discuss: Throw here?
         }
-      }
+      }  // end if signature page
       
       // The selector we'll use to set the DOM node's value later
       if ( !field_data.selector ) {
@@ -1021,19 +1105,19 @@ module.exports = {
         let href = node.attribs.href;
         let match = href.match( /action=([^&]*)/ );
         if ( match ) {
-          not_decoded_name = match[1];
+          encoded_name = match[1];
         } else {
           // Some action buttons just use urls instead of da actions
-          // This means the first guess of the name should be the not_decoded_name
+          // This means the first guess of the name should be the encoded_name
           // TODO: This only replaces the chars at the start of the string. Is that
           // intentional? Does this `.replace()` need the `g` flag?
-          not_decoded_name = href.replace(/^[A-Za-z0-9]*/, '_');
+          encoded_name = href.replace(/^[A-Za-z0-9]*/, '_');
         }
       }
 
-      if ( !not_decoded_name ) {
+      if ( !encoded_name ) {
         // Some fields, like comboboxes, have a weird var name setup
-        not_decoded_name = $node.attr( `id` );
+        encoded_name = $node.attr( `id` );
       }
 
       // ====================
@@ -1044,12 +1128,13 @@ module.exports = {
       if ( $node.hasClass('danota-checkbox') || $node.parents(`.da-field-container-datatype-object_radio`).name ) {
         is_none_of_the_above = true;
         let first_sib = $(node.parent).find( 'input' )[0];
-        not_decoded_name = first_sib.attribs.name;
+        encoded_name = first_sib.attribs.name;
         // TODO: Do we need daaota as well? ("all of the above")
       }
 
+      // Am I doing this wrong? the guesses aren't just the name, right?
       let var_names = await scope.getPossibleDecodedNames( scope, {
-        not_decoded: not_decoded_name,
+        not_decoded: encoded_name,
         field_like_names,
         is_none_of_the_above: is_none_of_the_above,
         proxies,
@@ -1070,16 +1155,260 @@ module.exports = {
         values.push( node.attribs.value );
       }
 
-      field_data.guesses = await scope.getPossibleTableRowMatchers( scope, { var_names, values });
-      fields.push( field_data );
+      field_data.guesses ??= await scope.add_values_if_needed( scope, { var_names, values });
+      if ( scope.is_button_ish( scope, { field: field_data }) ) {
+        // Discuss: This makes sure buttons are matched with table rows last. Is
+        //   that useful? Appropriate?
+        all_buttons.push( field_data );
+      } else {
+        fields.push( field_data );
+      }
+
     }  // ends for every node
 
+    let on_page = [ ...fields, ...all_buttons ];
+
     log.debug({ code: `ALK0124`, context: `page fields`, },
-      fields
+      JSON.stringify( on_page, null, 2 )
     );
-    return fields;
+    return on_page;
   },  // Ends scope.getAllFields()
 
+  get_question_data: async function ( scope ) {
+    /**
+     * Return server data about the current question.
+     * 
+     * da v1.10.n or greater removes some info from the DOM, such as on the
+     *   signature page, so we need to supplement our info when possible. We can
+     *   do this by making a GET request for the current page data in the
+     *   browser. See https://docassemble.org/docs/api.html#session_question. If
+     *   we had an API key for the user or an admin, we could use the API, but
+     *   we cannot guarantee having that API key without making a lot more work
+     *   for authors.
+     * 
+     * Discuss: Do we need to wait longer for a server response, as we do for a
+     *   page response?
+     * 
+     * @param {Object} scope - Tests state object
+     * 
+     * @returns {Object} - the question & field data from the current page
+     * */
+    let question_data = { ok: false, status: -1 };
+    let question_response = null;
+    let err_msg = `Docassemble couldn't process this page's JSON. ALKiln will`
+      + ` do its best, but may fail. We would love a report for this.`;
+
+    try {
+      question_response = await scope?.page?.evaluate?.( async ( err_msg ) => {
+        /**
+         * @returns {object} -
+         *   { ok: false };  // ok -> response status or false
+         *   | { ok, status, ...data, ...( await response.json() ) }
+         *   | { ok, status, alk_msg: err_msg, ...data, html: await response.text() }
+         *   | { ok, status, alk_msg: err_msg }
+         *   | { ok: false, alk_msg: err_msg, error: response_err.message }
+         * */
+        let data = { ok: false, alk_msg: null };  // ok -> did we get JSON or not
+        try {
+          let response = await fetch(
+            window.location.href.replace(`interview?`, `interview?json=1&`)
+          );
+
+          data.ok = response.ok;
+          data.status = response.status;
+
+          // ‼️ On system error caused by `GET` request, AL's da v1.9.n first
+          //   detects the error, but it stays invisible to the DOM since the
+          //   page hasn't been reloaded. Then, when the test presses to
+          //   continue, a new error appears. Unfortunately, the old error is
+          //   lost, so we won't be able to retrieve it through the DOM. We may
+          //   want to switch to catching errors during the field-getting part
+          //   of the life-cycle if we want to be able to handle this robustly.
+          //   I'm not sure what other issues will arise at that point.
+
+          let content_type = response?.headers?.get?.(`content-type`);
+          if ( content_type?.startsWith?.(`application/json`) ) {
+            return { ...data, ...( await response.json() ) };
+
+          } else if ( content_type?.startsWith?.(`text/plain`) ) {
+            // NOTE: Assembly Line will obscure docassemble error content it
+            //   doesn't handle, making its error page unhelpful. In future, we
+            //   do more with the actual page response.
+            return { ...data, alk_msg: err_msg, html: await response.text() };
+
+          } else {
+            // Research: How can we get in here? What other content-types that we
+            //   could get give response ok?
+            return { ...data, alk_msg: err_msg, content_type };
+          }  // ends content-type check
+
+        } catch ( response_err ) {
+          // Error might be caused by non-da page author navigated to when, for
+          //   example, testing an "Exit" destination.
+          return { ok: false, alk_msg: err_msg, error: response_err.message, }
+        }  // ends fetch try
+        
+        return data;
+      }, err_msg );  // ends page.evaluate() call
+    } catch ( question_data_error ) {
+      question_response = { ok: false, alk_msg: err_msg, error: question_data_error.message, }
+    }
+
+    question_data = question_response || question_data;
+    // If we didn't get JSON response, we're assuming fetch ran into a problem.
+    //   This isn't critical info. Other ALKiln code will throw if warranted.
+    if ( !question_data.ok ) {
+      scope.log_question_data_not_ok( scope, { data: question_data });
+      return { ok: false };
+    }
+
+    return question_data;
+  },  // Ends get_question_data
+
+  log_question_data_not_ok: function ( scope, { data={} }) {
+    /**
+     * Log question_data response props appropriately.
+     * 
+     * @param {Object} scope - Tests state object
+     * @param {Object} obj - Named args
+     * @param {Object} obj.data - Data for a non-JSON response to fetching
+     *     docassemble current question data
+     * 
+     * Possible data shapes:
+     *   { ok: false };  // ok -> response.ok or false
+     *   | { ok, status, ...data, ...( await response.json() ) }
+     *   | { ok, status, alk_msg: err_msg, ...data, html: await response.text() }
+     *   | { ok, status, alk_msg: err_msg, content_type }
+     *   | { ok: false, alk_msg: err_msg, error: response_err.message }
+     * 
+     * @returns {string} - Log text
+     * */
+    let default_msg = `ALKlin skipped processing the current page's server data.`;
+    let qst_msgs = [ data.alk_msg || default_msg, ]
+
+    if ( data.status || data.html || data.error || data.content_type ) { qst_msgs.push(``); }
+
+    if ( data.status ) { qst_msgs.push(`Response status: ${ data.status }`); }
+    if ( data.content_type ) { qst_msgs.push(`Content type: ${ data.content_type }`) }
+    if ( data.html ) {
+      let $ = cheerio.load( data.html );
+      qst_msgs.push( $('#damain')?.text?.() || data.html );
+    }
+    if ( data.error ) { qst_msgs.push( data.error ); }
+
+    return log.debug({ level: `warn`, code: `ALK0282`, context: `question_data`,
+      }, qst_msgs.join(`\n`));
+  },
+
+  canvas_name: {
+    try_for_best_encoded: function( scope, { existing_guesses, $, trigger }) {
+      /**
+       * Returns the canvas' encoded var instance name if possible. Otherwise
+       *   returns null.
+       * 
+       * @param {Object} scope - Tests state object
+       * @param {Object} obj - Named arguments
+       * @param {Object} obj.existing_guesses - List of existing guesses
+       * @param {Object} obj.$ - cheerio
+       * @param {Object} obj.trigger - Name of the var the interview is seeking
+       * 
+       * @returns {string} - Encoded variable instance name
+       * 
+       * @example
+       * scope.canvas_name.try_for_best_encoded( scope, { existing_guesses, $, trigger }
+       * // cHJveHlfbGlzdFswXS5zaWduYXR1cmU // decoded: people[0]...
+       * */
+      if ( existing_guesses?.length > 0 ) { return null; }
+      return (
+        // v1.9.n: If da server's config value of `restrict input
+        //   variables` set to True, `_save_as` should work to get the var
+        //   name. v 1.10.n, unknown
+        $(`input[name="_save_as"]`)?.attr?.(`value`)
+        || trigger  // From ALKiln custom HTML author may or may not be using
+        || null
+      );
+    },
+
+    try_for_mid_guesses: function( scope, { question_data }) {
+      /**
+       * If possible, returns a list of one string - a decoded instance name
+       *   that likely belongs to the canvas var. Otherwise returns null.
+       *   Example: people[0].signature.
+       * 
+       * @param {Object} scope - Tests state object
+       * @param {Object} obj - Named arguments
+       * @param {Object} obj.question_data - Docassemble server data about the
+       *     current question
+       * 
+       * @returns {array} - List of one decoded canvas element name
+       * 
+       * @example
+       * scope.canvas_name.try_for_mid_guesses( scope, { field_data, question_data })
+       * // people[0].signature  // If it's the first one in the list, that is
+       * */
+      // `event_list` contains decoded instance names of variables. Sadly, this
+      //   code assumes the first item of `event_list` is the canvas name. Note,
+      //   though, that I've been unable to trigger an event_list with multiple
+      //   items.
+      if ( question_data?.event_list?.[0] ) {
+        return [ question_data.event_list[0] ];
+      }
+      return null;
+    },
+
+    try_for_worse_guesses: function( scope, { question_data }) {
+      /**
+       * If possible, returns a list of one string - a decoded var name that
+       *   likely belongs to the canvas, but may contain x, i, or other such
+       *   proxy variable names instead of the intrinsic name. Otherwise returns
+       *   null. Example: x[i].signature. Note that I've been unable to trigger
+       *   a `fields` list with multiple items.
+       * 
+       * @param {Object} scope - Tests state object
+       * @param {Object} obj - Named arguments
+       * @param {Object} obj.question_data - Docassemble server data about the
+       *     current question
+       * 
+       * @returns {[string]} - List of one decoded canvas, maybe proxy, var name
+       * 
+       * @example
+       * scope.canvas_name.try_for_mid_guesses( scope, { question_data })
+       * // x[i].signature
+       * */
+      // The canvas should be the only field on the page, so the assumption that
+      //   the canvas's name is the first item of `fields` should be reasonable.
+      if ( question_data?.fields?.[0]?.variable_name ) {
+        return [ question_data.fields[0].variable_name ];
+      }
+      return null;
+    },
+
+    try_for_worse_encoded: function( scope, { question_data }) {
+      /**
+       * If possible, returns an encoded var name that likely belongs to the
+       *   canvas, but may contain x, i, or other such proxy variable names
+       *   instead of the intrinsic name. Otherwise returns null. Example:
+       *   x[i].signature. Note that I've been unable to trigger a `fields` list
+       *   with multiple items.
+       * 
+       * @param {Object} scope - Tests state object
+       * @param {Object} obj - Named arguments
+       * @param {Object} obj.question_data - Docassemble server data about the
+       *     current question
+       * 
+       * @returns {string} - Encoded canvas, maybe proxy, var name
+       * 
+       * @example
+       * scope.canvas_name.try_for_mid_guesses( scope, { question_data })
+       * // eFtpXS5zaWduYXR1cmU  // Decodes to x[i].signature
+       * */
+      // The canvas should be the only field on the page, so assuming the
+      //   canvas's name the first item of `fields` should be reasonable.
+      // Last resort, encoded name. Example: eFtpXS5zaWduYXR1cmU which decodes to (x[i]...).
+      return question_data?.fields?.[0]?.variable_name_encoded;
+    },
+  },
+
   getPageJSON: async function ( scope ) {
     /* Get the JSON data of the current page. */
     return await scope.page.evaluate(async function ( elem ) {
@@ -1103,6 +1432,7 @@ module.exports = {
     if ( node.attribs.value ) { selector += `[value="${ node.attribs.value }"]`; }
     if ( node.attribs.id ) { selector += `[id="${ node.attribs.id }"]`; }
     if ( node.attribs.class ) { selector += `[class="${ node.attribs.class }"]`; }
+    if ( node.attribs.role ) { selector += `[role="${ node.attribs.role }"]`; }
     if ( $( node ).attr( 'data-linknum' )) { selector += `[data-linknum="${ $( node ).attr( 'data-linknum' ) }"]`; }
     // Everything should be in #daquestion and that's also how our unit tests and fixtures work.
     selector = '#daquestion ' + selector;
@@ -1122,12 +1452,12 @@ module.exports = {
     return selector;
   },  // Ends scope.getSelector()
 
-  getPossibleTableRowMatchers: async function ( scope, { var_names, values }) {
+  add_values_if_needed: async function ( scope, { var_names, values }) {
     /* Return variable names and values combined in ways that can
     * try to match table rows. Tables can have two properties:
-    * variable name and value. */
+    * variable name and value. Despite it's name, non-mutating. */
     log.debug({ code: `ALK0126`, context: `matching`, },
-      `scope.getPossibleTableRowMatchers() var_names:`, var_names, `values:`, values
+      `scope.add_values_if_needed() var_names:`, var_names, `values:`, values
     );
     let possible_table_rows = [];
     for ( let var_name of var_names ) {
@@ -1156,7 +1486,7 @@ module.exports = {
     }  // end iterate through row possibilities
 
     return possible_table_rows;
-  },  // Ends scope.getPossibleTableRowMatchers()
+  },  // Ends scope.add_values_if_needed()
 
   getFieldNamesDict: async function ( scope, { $ }) {
     /* Returns an object containing a map of the `_field_n` names and
@@ -1397,7 +1727,7 @@ module.exports = {
       if ( opt.attribs.value !== undefined ) {
         options.push( opt.attribs.value );
       }
-      // Dropdowns created w/ objects are base64 encoded; but it's handled in getPossibleTableRowMatchers
+      // Dropdowns created w/ objects are base64 encoded; but it's handled in add_values_if_needed
     }
     return options;
   },  // Ends scope.getOptionValues()
@@ -1716,6 +2046,7 @@ module.exports = {
     // Pass in the selector as an argument
     }, field.selector );
 
+
     return handle;
   },  // Ends scope.get_handle_from_field()
 
@@ -1852,6 +2183,10 @@ module.exports = {
       await scope.tapElementAndNavigate( scope, { elem: handle });
       return true;
     },
+    a: async function ( scope, { handle, answer }) {
+      await scope.tapElementAndNavigate( scope, { elem: handle });
+      return true;
+    },
     textarea: async function ( scope, { handle, answer }) {
       await scope.setText( scope, { handle, answer });
       await scope.afterStep(scope);  // No showifs for this one?
@@ -1895,7 +2230,7 @@ module.exports = {
       /* Set value of some `input` element to the given value. */
       let row_was_used = true;
 
-      let type = await handle.evaluate( elem => { 
+      let type = await handle.evaluate( elem => {
         if (elem) {
           return elem.getAttribute('type'); 
         } else {
@@ -2076,28 +2411,112 @@ module.exports = {
       return false;
     }
 
-    // Prepare to wait for upload to complete
-    let name = await handle.evaluate( elem => { return elem.getAttribute(`name`); });
-    let selector = `*[name="${ name }"]`
-    let disabled_selector = `${ selector }[disabled]`;
-    let enabled_selector = `${ selector }:not([disabled])`;
+    // ✏️ The code below is a great indication that Log and `reports`
+    //   architecture may be less than ideal, though js doesn't help.
+
+    // TODO: Pass in a promise aborter to page.evaluate() if possible, though
+    //   it's not completely necessary. If the gobal `setTimeout` fires then the
+    //   `evaluate` won't be far behind. They both use about the same timeout
+    //   duration.
+    let finish_uploading = handle.evaluate( async function detect_finished_upload(
+      elem, timeout, answer
+    ) {
+      return new Promise (( resolve, reject ) => {
+        /**
+         * Resolve when upload completes. Logging in here will log to the hidden
+         *   browser. Must instead pass information out with `resolve`.
+         * */
+        // Warn about uploading the same file multiple times
+        // Won't protect against accidentally uploading same file to diff field
+
+        // If elem.files, the author has previously set this field. Warn them.
+        // Example prev_filenames: "C:\\fakepath\\name_of_file.png"
+        let prev_filenames = [];
+        let shared_names_list = [];
+        let all_matched = true;
+        for ( let file_obj of elem.files ) {
+          let filename = file_obj.name.slice( 12, file_obj.name.length );
+          prev_filenames.push( filename );
+          // May over-match with names that end the same way
+          if ( answer.includes( filename ) ) {
+            shared_names_list.push( filename );
+          } else {
+            all_matched = false;
+          }
+        }
+
+        let result = {
+          ok: false, prev_filenames, type: null,
+          code: `ALK0283`, level: `debug`, msgs: [], error: null,
+        };
 
-    // This comes before the upload starts.
-    // Notice `await` is absent. Don't actually wait here yet.
-    // Start looking for it before it exists or we might miss it.
-    let wait_for_disable = scope.page.waitForSelector( disabled_selector );
+        if ( prev_filenames ) {
+          result.level = `warn`;  // log level
+          result.type = `warning`;  // report type
+          shared_names = shared_names_list.join(`", "`);
+
+          if ( shared_names_list.length > 0 ) {
+            if ( all_matched ) {
+              result.code = `ALK0284`;
+              result.msgs.push(`Previously, you uploaded these files to this field: "${ answer }". Just now you tried to upload these files to this field: "${ shared_names }". Those names closely match. Did you mean them to be different?`);
+            } else {
+              result.code = `ALK0285`;
+              result.msgs.push(`Previously, you uploaded these files to this field: "${ answer }". Just now you tried to upload these files to this field: "${ shared_names }". Some of those names closely match. Did you mean them to be different?`);
+            }
+          } else {
+            result.code = `ALK0286`;
+            result.msgs.push(`You already uploaded some files to the current field. Did you mean to do that?`);
+          }
+        }
+
+        let timeout_id = null;
+        let resolve_on_change = function() {
+          result.ok = true;  // May contain warnings
+          clearTimeout( timeout_id );
+          result.msgs.push(`Finished uploading these files: "${ answer }"`);
+          resolve( result );
+        };
+
+        timeout_id = setTimeout(() => {
+          elem.removeEventListener(`change`, resolve_on_change );
+          result.level = `throw`;
+          result.type = `error`;
+          result.code = `ALK0281`;
+          // Discuss: Will the trace be confusing from here?
+          result.msgs.push(`It took more than ${( timeout - 100 )/1000 } seconds to try to upload the file(s) "${ answer }".`);
+          // ⚠️ Unable to pass Error out of page.evaluate. Must use string.
+          result.error = `Timeout error: It took too long to upload the files.`;
+          resolve( result );
+        }, timeout );
+
+        elem.value = null;
+        elem.addEventListener(`change`, resolve_on_change );
+      });  // ends Promise
+
+    }, scope.timeout - 100, answer );  // ends page.evaluate()
     
-    // Upload
     await handle.uploadFile(...paths);
 
-    // Halt progress to wait for the input to be disabled. If it already is, then this
-    // will have resolved already and will keep going.
-    await wait_for_disable;
-    // When it's again enabled, the files have finished loading. Or so I have observed.
-    await scope.page.waitForSelector( enabled_selector );
+    // Wait for upload to finish. If already done, execution will continue
+    let { ok, type, level, code, error, msgs } = await finish_uploading;
+
+    let report_vals = msgs;
+    if ( error ) {
+      // ⚠️ Unable to get Error out of page.evaluate. Must create it here.
+      error = new Error( error );
+      report_vals.push( error );
+    }
+    if ( type !== null ) {
+      reports.addToReport(scope, { type, code, value: report_vals.join(`\n`) });
+    }
 
-    // Return that the row was used
-    return true;
+    // The ternary calls, but the need for it smells like bad code to me.
+    let log_type = `debug`;
+    if ( level === `throw` ) { log_type = `throw`; }
+    log[ log_type ]({ code, level, error, context: `file_upload`}, ...msgs );
+
+    // Return whether successfully used row
+    return ok;
   },  // Ends scope.uploadFiles()
 
   setCheckbox: async function ( scope, { label, answer }) {
@@ -2150,7 +2569,7 @@ module.exports = {
     let canvas = await scope.page.waitForSelector( `#dasigcanvas` );
     let msg = `Could not find a signature field.`;
     if ( !canvas ) { reports.addToReport(scope, { type: `error`, code: `ALK0137`, value: msg }); }
-    expect( canvas, msg ).to.exist;
+    expect( canvas, msg ).to.not.be.null;
 
     // Provides functionality to draw name arg on canvas
     if (name !== undefined) {
@@ -2163,7 +2582,9 @@ module.exports = {
     let bounding_box = await canvas.boundingBox();
     // We draw the dot because it allows the developer to tap continue
     // Docassemble does not allow to tap continue unless the user interacts with the canvas
-    await scope.page.mouse.move(bounding_box.x + bounding_box.width / 2, bounding_box.y + bounding_box.height / 2);
+    let pen_x = (bounding_box.x + bounding_box.width / 2) + Math.random() * 50;
+    let pen_y = (bounding_box.y + bounding_box.height / 2) + Math.random() * 50;
+    await scope.page.mouse.move( pen_x, pen_y );
     await scope.page.mouse.down();
     // await scope.page.mouse.move(1, 1);  // Too big? Wait a while before drawing?
     await scope.page.mouse.up();
@@ -2253,6 +2674,8 @@ module.exports = {
       `scope.setFields()`
     );
 
+    let error_data = null;
+
     // Only record the page id once for each page to which we navigate
     let { id } = await scope.examinePageID( scope, 'none to match' );
     if ( scope.page_id !== id ) {
@@ -2278,7 +2701,9 @@ module.exports = {
         if ( field.was_set ) { continue; }
         // Avoid navigating in this `while`. Will do this later so we get to
         // set all fields in here first. TODO: Can links (<a>) set vars?
-        if ( field.tag === 'button' && field.type === 'submit' ) { continue; }
+        if (
+          scope.is_button_ish( scope, { field }) && field.type === `submit`
+        ) { continue; }
 
         // Try to set other types of fields
         let row_used = await scope.setVariable( scope, { field, var_data });
@@ -2307,7 +2732,7 @@ module.exports = {
     let error = {};
     for ( let field of fields ) {
       // All other fields should have been set
-      if ( field.tag === 'button' && field.type === 'submit' ) {
+      if ( scope.is_button_ish( scope, { field }) && field.type === 'submit' ) {
         let page_url = await scope.page.url();
 
         let row_used = await scope.setVariable( scope, { field, var_data, });
@@ -2334,10 +2759,7 @@ module.exports = {
           // Make sure no system or user error messages appear
           // Discuss moving this out of here. Having to pass in `id` just for
           // these messages smells bad. Con: Already a lot of code out there.
-          error = await scope.waitUntilContinued( scope, { url: page_url, id });
-          // if ( error.was_found ) {
-          //   await scope.throwPageError( scope, { id: id });
-          // }
+          error_data = await scope.waitUntilContinued( scope, { url: page_url, id });
 
           did_navigate = true;
           log.stdout({}, `\x1b[36m${ 'v' }\x1b[0m`);  // pressed button successfully
@@ -2351,17 +2773,16 @@ module.exports = {
     if ( ensure_all_vars_used ) {
       for ( let row of var_data ) {
         if ( row.times_used === 0 ) {
-          let values_used_status = 'The page is missing a value';
           let source_row = row;
           // TODO: Make the row object flatter so we don't need to dig in this way
           if ( row.source ) { source_row = row.source; }
           let original_row = source_row.original;
           let { id } = await scope.examinePageID( scope, 'none to match' );
           let msg = `In a linear Step all the values you give MUST be filled in, but ALKiln was unable `
-            + `to find a field on the page "${id}" for the variable "${ original_row.var }" that `
+            + `to find a field on the page with the "${ id }" for the variable "${ original_row.var }" that `
             + `could be set to "${ original_row.value }". See this Scenario's HTML file for details.`;
           reports.addToReport(scope, { type: `error`, code: `ALK0141`, value: msg });
-          expect( values_used_status, msg ).to.equal( '' );
+          expect( 'The page is missing a field', msg ).to.equal( '' );
         }
       }
     }
@@ -2380,11 +2801,7 @@ module.exports = {
       // Discuss moving this out of here. Having to pass in `id` just for
       // these messages smells bad. Con: Already a lot of code out there.
 
-      // TODO: How do we let 'I set the var __ to __' also afterwards check for an invalidation message?
-      error = await scope.waitUntilContinued( scope, { url: page_url, id });
-      // if ( error.was_found ) {
-      //   await scope.throwPageError( scope, { id: id });  
-      // }
+      error_data = await scope.waitUntilContinued( scope, { url: page_url, id });
 
       did_navigate = true;
       log.stdout({}, `\x1b[36m${ '>' }\x1b[0m`);  // continued successfully
@@ -2400,10 +2817,29 @@ module.exports = {
     // TODO: Since we now continue only once no matter what, we can put
     // the error in the caller of the function, though we may want
     // to pass the symbol to print as well.
-    return error;
+    return error_data;
     // TODO: Maybe we should return something else or something in addition about used vars
   },  // Ends scope.setFields()
 
+  is_button_ish: function ( scope, { field = null }) {
+    /**
+     * Return true if the field is similar enough to a button, else false. This
+     *   does NOT determine whether the field submits the form.
+     * 
+     * Discuss: Use "btn" class as well?
+     * 
+     * @param {Object} scope - Tests state object
+     * @param {Object} field - One field from `.getAllFields()`
+     * 
+     * @returns bool
+     * */
+    if ( field.tag === `button`
+          || field.selector.includes(`role="button"`)
+          || field.selector.includes(`.dasigsave`)
+       ) { return true; }
+    return false;
+  },
+
   increment_row_use: async function ( scope, { row }) {
     /** Accumulate number of times this row was used. Esp important for `.target_number`.
     *   Mutates `row` and its props. */
@@ -2641,16 +3077,22 @@ module.exports = {
         is found. Return the error object no matter what. */
     let prev_url = url;
     let curr_url = await scope.page.url();
-    let error = await scope.checkForError( scope );
+    let error_data = await scope.checkForError( scope );
 
     let timedOut = false;  // Lazy timeout?
     let cont_timeout = setTimeout(function(){ timedOut = true }, scope.timeout);
 
     // Attempt to solve weird race condition issues where page has not properly continued
-    while ( curr_url === prev_url && !error.was_found && !timedOut ) {
+    while ( curr_url === prev_url && error_data.ok && !timedOut ) {
       await time.waitForTimeout( 50 );
       curr_url = await scope.page.url();
-      error = await scope.checkForError( scope );
+      error_data = await scope.checkForError( scope );
+    }
+
+    if ( !error_data.ok ) {
+      await scope.throw_system_error( scope, { error_data, id: id });
+      // If trying to continue, shouldn't be running into user errors either
+      await scope.throw_invalid_answer( scope, { error_data, id: id });
     }
 
     let timeout_err_message = `The test tried to continue to the next page, but it took longer than ${ (scope.timeout/1000)/60 } min. Check the picture of this page. If a secret variable was used, there will be no picture.`
@@ -2659,7 +3101,7 @@ module.exports = {
 
     clearTimeout( cont_timeout );
 
-    return error;
+    return error_data;
   },  // Ends scope.waitUntilContinued()
 
   checkForError: async function ( scope ) {
@@ -2667,20 +3109,22 @@ module.exports = {
     * returns those elements. The error elements are probably exclusive, but
     * we're not sure. */
 
-    // All results are lists to match `$x`
-    let possible_errors = {
-      complex_user_error: await scope.page.$$(`.alert-danger`),
+    // All results are lists to match puppeteerjs `$x`
+    let possible_error_types = [
+      // TODO: Be more specific. Author can also use a `.alert-danger` call out.
+      { type: `user`, handlers: await scope.page.$$(`.alert-danger`) },
       // The below does not work if there's not a space between ':' and 'none'
-      simple_user_error: await scope.page.$$(`xpath/.//*[contains(@class, "da-has-error")][not(contains(@style,"display: none"))]`),
-      system_error: await scope.page.$$(`xpath/.//meta[@content="docassemble: Error"]` ),
+      { type: `user`, handlers: await scope.page.$$(`xpath/.//*[contains(@class, "da-has-error")][not(contains(@style,"display: none"))]`) },
+      { type: `system`, handlers: await scope.page.$$(`xpath/.//meta[@content="docassemble: Error"]` ) },
       // Hardcoding the `al_custom_error_action` screen (that's what the base64 here is). It hides actual errors and looks like a continue screen, but isn't.
-      al_custom_error: await scope.page.$$('.question-custom-error-action .daattributions #trigger[data-variable="YWxfY3VzdG9tX2Vycm9yX2FjdGlvbg"]'),
-    };
+      { type: `system`, handlers: await scope.page.$$('.question-custom-error-action .daattributions #trigger[data-variable="YWxfY3VzdG9tX2Vycm9yX2FjdGlvbg"]') },
+    ];
 
-    let error_handlers = {};
+    let error_handlers = [];  // TODO: Refactor to be single item
     let was_found = false;
-    for ( let error_key in possible_errors ) {
-      if ( possible_errors[ error_key ][0] ) {
+    let type = null;
+    for ( let one_err_type of possible_error_types ) {
+      if ( one_err_type.handlers[0] ) {
         // If there's a page visible (locally), give us as much time to examine it as timeout allows.
         // Because of previous actions, this may still be a bit too long.
         // Also, if you're debugging and you close the window early, the process will still
@@ -2689,36 +3133,53 @@ module.exports = {
           await time.waitForTimeout( ( scope.timeout - (1 * 1000)) );
         }
         was_found = true;
-        error_handlers[ error_key ] = possible_errors[ error_key ][0];
+        type = one_err_type.type
+        error_handlers.push( one_err_type.handlers[0] );
+        break;
       }
     }
 
-    return { was_found, error_handlers };
+    return { was_found, ok: !was_found, type, error_handlers };
   },  // Ends scope.checkForError()
 
-  throwPageError: async function ( scope, { error_handlers = {}, id = '' }) {
-    /* Throw a cucumber error with the error that appeared on the page. */
-    if ( error_handlers.system_error !== undefined ) {
-      let sys_err_message = `The test tried to continue to the next page after ${ id }, but there was a system error. Check the picture of this page.`
-      reports.addToReport(scope, { type: `error`, code: `ALK0147`, value: sys_err_message });
-      expect( was_system_error, sys_err_message ).to.be.false;
+  throw_system_error: async function ( scope, {
+    error_data = null, error_handlers = null, id = ``, error_text = ``
+  }) {
+    /** Throw a cucumber error with the error that appeared on the page. */
+    let was_system_error = error_data?.type === `system`
+      || error_handlers?.system_error !== undefined
+      || error_handlers?.al_custom_error !== undefined;
+
+    if ( was_system_error ) {
+      let err_msg = `The test ran into a system error when it tried to continue to the next page after "${ id }". Also check the picture of this page.`;
+      let report_msg = reports.addToReport(scope, { type: `error`, code: `ALK0147`, value: err_msg });
+      expect( was_system_error, report_msg ).to.be.false;
+    }
+
+    return scope;
+  },  // Ends scope.throw_system_error()
 
-    } else {
-      // If it wasn't a system error, it was a user error
-      let user_err_message = `The test tried to continue to the next page after ${ id }, but the user got an error. Check the picture of this page.`
-      reports.addToReport(scope, { type: `error`, code: `ALK0148`, value: user_err_message });
-      expect( true, user_err_message ).to.be.false;
+  throw_invalid_answer: async function ( scope, {
+    error_data = {}, id = ''
+  }) {
+    // It was a user error, which the author may be expecting
+    if ( !error_data.ok && error_data.type === `user` ) {
+      let err_msg = `There was an invalid answer when the test tried to continue to the next page after ${ id }. Check the picture of this page.`;
+      let report_msg = reports.addToReport(scope, { type: `warning`, code: `ALK0148`, value: err_msg });
+      expect( error_data.type === `user`, report_msg ).to.be.false;
     }
 
     return scope;
-  },  // Ends scope.throwPageError()
+  },  // Ends scope.throw_invalid_answer()
 
   take_a_screenshot: async ( scope,{ path }) => {
     /* Takes a jpeg screenshot. Avoids destroying signatures. */
 
     let fullPage = true;
-    let signature_elem = await scope.page.$(scope.signature_selector);
-    signature_elem = signature_elem || await scope.page.$(scope.signature_selector_backup);
+    // Use only $ as opposed to $$ - just checking for presence of any element
+    let signature_elem = await scope.page.$(scope.signature_cont_btn_selector_da_v_1_9_n_and_earlier, { visible: true })
+      || await scope.page.$(scope.signature_cont_btn_selector_backup_da_v_1_9_n_and_earlier, { visible: true })
+      || await scope.page.$(scope.signature_cont_btn_selector_da_v_1_10_n_and_later, { visible: true });
     if ( signature_elem !== null ) {
       fullPage = false;
     }
@@ -2948,8 +3409,6 @@ module.exports = {
       }
 
       // TODO: Add debug log here
-      // console.log(`filename:`, filename);
-
       // TODO: Add to the report if we had to use the default name
 
       return filename;
@@ -3236,7 +3695,12 @@ module.exports = {
     },
 
     set_random_page_vars: async ( scope ) => {
-      /** Answer inputs randomly. */
+      /**
+       * Give random answers to every field.
+       * 
+       * ⚠️ Keep hidden fields! With some customdatatypes, we set their values.
+       * 
+       * */
 
       let html = await scope.page.content();
       // These are the fields on the current page. Their handles should all exist.
@@ -3247,8 +3711,11 @@ module.exports = {
       for ( let field of fields ) {
         // fields[n].tag is HTML tag of node, as a string
 
-        // If the field is a button, save it in a list of buttons that we'll deal with later
-        if ( field.tag === `button` ) {
+        // ⚠️ Keep hidden fields! With some customdatatypes, we set their vals.
+
+        // If the field is a button, save it in a list of buttons that we'll
+        //   deal with later
+        if ( scope.is_button_ish( scope, { field }) ) {
           buttons.push( field );
         } else {
           // Try to give a random answer for that element tag
@@ -3265,15 +3732,24 @@ module.exports = {
   },  // ends scope.steps
 
   set_random_input_for: {
+    /**
+     * ‼️ We call these methods with `set_random_input_for[ tag ]`. You will not
+     *   find them called explicitly.
+     * */
     a: async function (scope, { fields }) {
       // We don't do anything with links for random input tests
     }, 
     buttons: async function (scope, { fields }) {
       // Get a random button
       let back_btn = null;
-      fields = fields.filter((ff) => {
-        if (ff.selector.includes("daquestionbackbutton")) {
-          back_btn = ff;
+      fields = fields.filter( async( field ) => {
+        if ( field.selector.includes("daquestionbackbutton") ) {
+          back_btn = field;
+          return false;
+        }
+        let handle = await scope.page.$( field.selector );
+        let bounding_box = await handle?.boundingBox();
+        if ( bounding_box?.height === 0 || bounding_box?.width === 0) {
           return false;
         }
         return true;
@@ -3330,10 +3806,10 @@ module.exports = {
 
     },
     canvas: async function (scope, { field }) {
-      // WARNING: Do not test this in headless mode.
-      // If we do this in headless mode, the test will fail. It signs, but
-      // can't continue. Not sure why.
-      await scope.funnel_the_answer( scope, { field, handle: null, answer: `doesn't matter` });
+      let handle = await scope.page.waitForSelector(`#dasigcanvas`);
+      // We cannot be sure of knowing the name of the signer and so want to
+      //   indicate it's random, but we do want something unique
+      await scope.funnel_the_answer( scope, { field, handle, answer: `Random ${ faker.name.lastName() }` });
     },
     input: async function (scope, { field }) {
       /** Handles various `type`s of input element fields, except:
@@ -3361,8 +3837,7 @@ module.exports = {
 
       // If this is a custom datatype
       let custom_datatype = await scope.get_custom_datatype( scope, { handle });
-      let is_custom_datatype = scope.get_random_input_for[ custom_datatype ] !== undefined;
-      if ( is_custom_datatype ) {
+      if ( scope.get_random_input_for[ custom_datatype ] !== undefined ) {
         // And the custom datatype has a hidden field (which will be the original field)
         let hidden_field = await scope.get_custom_datatype_hidden_field( scope, { handle });
         if ( hidden_field !== null ) {