Add ElementHandle.WaitForSelectorAsync()

Hello. Could we add WaitForSelectorAsync for ElementHandle There are few reasons for such functionality

1. Performance. There is no reason to query whole document if we can query only subset
2. And when you have multiple similar nodes and you want to monitor one certain node, and there is no way to do this.

Currently I have second issue. And here is how I solve it with extension method. I used reflection because WaitTask is internal

public static Task<ElementHandle> WaitForSelectorAsync(this ElementHandle element, string selector, WaitForSelectorOptions options = null)
            => WaitForSelectorOrXPathAsync(element, selector, false, options);
public static Task<ElementHandle> WaitForXPathAsync(this ElementHandle element, string xpath, WaitForSelectorOptions options = null)
            => WaitForSelectorOrXPathAsync(element, xpath, true, options);

public static async Task<ElementHandle> WaitForSelectorOrXPathAsync(this ElementHandle element, string selectorOrXPath, bool isXPath, WaitForSelectorOptions options = null)
        {
            options = options ?? new WaitForSelectorOptions();
            const string predicate = @"
              function predicate(rootElement,selectorOrXPath, isXPath, waitForVisible, waitForHidden) {
                const node = isXPath
                  ? rootElement.evaluate(selectorOrXPath, rootElement, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue
                  : rootElement.querySelector(selectorOrXPath);
                if (!node)
                  return waitForHidden;
                if (!waitForVisible && !waitForHidden)
                  return node;
                const element = node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
                const style = window.getComputedStyle(element);
                const isVisible = style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
                const success = (waitForVisible === isVisible || waitForHidden === !isVisible);
                return success ? node : null;
                function hasVisibleBoundingBox() {
                  const rect = element.getBoundingClientRect();
                  return !!(rect.top || rect.bottom || rect.width || rect.height);
                }
              }";
            var polling = options.Visible || options.Hidden ? WaitForFunctionPollingOption.Raf : WaitForFunctionPollingOption.Mutation;
            var type = typeof(WaitForFunctionPollingOption).Assembly.GetType("PuppeteerSharp.WaitTask");
            var consturtor= type.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0];
           var waitTask = consturtor.Invoke(new object[]
           {
               element.ExecutionContext.Frame,
               predicate,
               false,
               $"{(isXPath ? "XPath" : "selector")} '{selectorOrXPath}'{(options.Hidden ? " to be hidden" : "")}",
               options.Polling,
               options.PollingInterval,
               options.Timeout,
               new object[]
               {
                   element,
                   selectorOrXPath,
                   isXPath,
                   options.Visible,
                   options.Hidden
               }
           });
           var p = type.GetProperty("Task", BindingFlags.Instance | BindingFlags.NonPublic);

          Task<JSHandle> t=  (Task<JSHandle>) p.GetValue(waitTask);
          JSHandle handle = await  t.ConfigureAwait(false);

            return handle as ElementHandle;
        }

There is only few changes.

========================== Also please explain me what this line do var polling = options.Visible || options.Hidden ? WaitForFunctionPollingOption.Raf : WaitForFunctionPollingOption.Mutation;

I can see that no one use variable ‘polling’

[Gdocal]

@kblok I would appreciate if you can do it

[kblok]

Our bad on the Polling code. I don’t want to add here any API which is not on Puppeteer.

I think you could add that feature on https://github.com/hlaueriksson/puppeteer-sharp-contrib

cc @hlaueriksson