puppeteer-ruby 0.45.6 → 0.50.0.alpha5

data/lib/puppeteer/execution_context.rb

@@ -1,3 +1,5 @@
+# rbs_inline: enabled
+
 class Puppeteer::ExecutionContext
   include Puppeteer::IfPresent
   using Puppeteer::DefineAsyncMethod
@@ -109,7 +111,7 @@ class Puppeteer::ExecutionContext
       # But we don't support the syntax here.
 
       result = client.send_message('Runtime.callFunctionOn',
-        functionDeclaration: "#{@expression}\n#{suffix}\n",
+        functionDeclaration: function_declaration,
         executionContextId: context_id,
         arguments: converted_args,
         returnByValue: @return_by_value,
@@ -146,6 +148,10 @@ class Puppeteer::ExecutionContext
       #     if (Object.is(arg, NaN))
       #       return { unserializableValue: 'NaN' };
       @args.map do |arg|
+        if recursive_object?(arg)
+          raise EvaluationError.new('Recursive objects are not allowed.')
+        end
+
         if arg && arg.is_a?(Puppeteer::JSHandle)
           if arg.context != @execution_context
             raise EvaluationError.new('JSHandles can be evaluated only in the context they were created!')
@@ -154,12 +160,141 @@ class Puppeteer::ExecutionContext
           end
 
           arg.remote_object.converted_arg
+        elsif arg.is_a?(Regexp)
+          { value: arg.source }
         else
           { value: arg }
         end
       end
     end
 
+    # @rbs value: untyped -- Value to check for cycles
+    # @rbs stack: Hash[Integer, bool]? -- Current stack for cycle detection
+    # @rbs visited: Hash[Integer, bool]? -- Already visited objects
+    # @rbs return: bool -- Whether the value contains cycles
+    private def recursive_object?(value, stack = nil, visited = nil)
+      return false unless value.is_a?(Hash) || value.is_a?(Array)
+
+      stack ||= {}
+      visited ||= {}
+      object_id = value.object_id
+      return true if stack[object_id]
+      return false if visited[object_id]
+
+      visited[object_id] = true
+      stack[object_id] = true
+
+      has_cycle =
+        if value.is_a?(Array)
+          value.any? { |item| recursive_object?(item, stack, visited) }
+        else
+          value.any? do |key, item|
+            recursive_object?(key, stack, visited) || recursive_object?(item, stack, visited)
+          end
+        end
+
+      stack.delete(object_id)
+      has_cycle
+    end
+
+    # @rbs return: String -- JavaScript function declaration
+    private def function_declaration
+      expression = @return_by_value ? serialized_function_declaration : @expression
+      "#{expression}\n#{suffix}\n"
+    end
+
+    # @rbs return: String -- Wrapped function with serialization
+    private def serialized_function_declaration
+      <<~JAVASCRIPT
+      async function(...__args) {
+        const fn = #{@expression};
+        const result = await fn.apply(globalThis, __args);
+        #{serialized_value_source}
+      }
+      JAVASCRIPT
+    end
+
+    # @rbs return: String -- JavaScript serialization helper source
+    private def serialized_value_source
+      <<~JAVASCRIPT
+      const OMIT = Symbol('omit');
+      const UNDEFINED_SENTINEL = { __puppeteer_unserializable__: true };
+      const NUMBER_SENTINEL = (value) => ({ __puppeteer_number__: value });
+      const REGEXP_SENTINEL = (source, flags) => ({ __puppeteer_regexp__: { source, flags } });
+      const seen = new WeakSet();
+      const isPlainObject = (value) => {
+        if (!value || typeof value !== 'object') {
+          return false;
+        }
+        const proto = Object.getPrototypeOf(value);
+        return proto === Object.prototype || proto === null;
+      };
+      const serialize = (value, allowOmit) => {
+        if (value === undefined) {
+          return allowOmit ? OMIT : UNDEFINED_SENTINEL;
+        }
+        if (typeof value === 'symbol' || typeof value === 'function') {
+          return UNDEFINED_SENTINEL;
+        }
+        if (typeof value === 'number') {
+          if (Number.isNaN(value)) {
+            return NUMBER_SENTINEL('NaN');
+          }
+          if (Object.is(value, -0)) {
+            return NUMBER_SENTINEL('-0');
+          }
+          if (value === Infinity) {
+            return NUMBER_SENTINEL('Infinity');
+          }
+          if (value === -Infinity) {
+            return NUMBER_SENTINEL('-Infinity');
+          }
+        }
+        if (typeof value === 'bigint') {
+          return value;
+        }
+        if (value === null || typeof value !== 'object') {
+          return value;
+        }
+        if (typeof Window !== 'undefined' && value === window) {
+          return UNDEFINED_SENTINEL;
+        }
+        if (typeof ImageBitmap !== 'undefined' && value instanceof ImageBitmap) {
+          return UNDEFINED_SENTINEL;
+        }
+        if (value instanceof RegExp) {
+          return REGEXP_SENTINEL(value.source, value.flags || '');
+        }
+        if (value instanceof Promise) {
+          return {};
+        }
+        if (seen.has(value)) {
+          return UNDEFINED_SENTINEL;
+        }
+        seen.add(value);
+        if (Array.isArray(value)) {
+          return value.map((item) => {
+            const serialized = serialize(item, false);
+            return serialized === OMIT ? UNDEFINED_SENTINEL : serialized;
+          });
+        }
+        if (!isPlainObject(value)) {
+          return UNDEFINED_SENTINEL;
+        }
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+          const serialized = serialize(val, true);
+          if (serialized === OMIT) {
+            continue;
+          }
+          result[key] = serialized;
+        }
+        return result;
+      };
+      return serialize(result, false);
+      JAVASCRIPT
+    end
+
     #   /**
     #    * @param {!Error} error
     #    * @return {!Protocol.Runtime.evaluateReturnValue}
@@ -180,7 +315,7 @@ class Puppeteer::ExecutionContext
     end
   end
 
-  class EvaluationError < StandardError; end
+  class EvaluationError < Puppeteer::Error; end
 
   # @param return_by_value [Boolean]
   # @param page_function [String]
@@ -190,7 +325,7 @@ class Puppeteer::ExecutionContext
     # https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Operators/Object_initializer
     # But we don't support the syntax here.
     js_object =
-      if ['=>', 'async', 'function'].any? { |keyword| page_function.include?(keyword) }
+      if function_string?(page_function)
         JavaScriptFunction.new(self, page_function, args, return_by_value)
       else
         JavaScriptExpression.new(self, page_function, return_by_value)
@@ -201,4 +336,14 @@ class Puppeteer::ExecutionContext
       context_id: @context_id,
     )
   end
+
+  # @rbs page_function: String -- JavaScript code to check
+  # @rbs return: bool -- Whether the code represents a function
+  private def function_string?(page_function)
+    stripped = page_function.lstrip
+    return true if page_function.include?('=>')
+    return true if stripped.start_with?('async function')
+
+    stripped.start_with?('function')
+  end
 end

data/lib/puppeteer/file_chooser.rb

@@ -25,5 +25,11 @@ class Puppeteer::FileChooser
       raise 'Cannot cancel FileChooser which is already handled!'
     end
     @handled = true
+    js = <<~JAVASCRIPT
+    (element) => {
+      element.dispatchEvent(new Event('cancel', { bubbles: true }));
+    }
+    JAVASCRIPT
+    @element.evaluate(js)
   end
 end