opal-vite 0.2.3 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e029e7e67ed9e66aa052a3a3d22270d54dae425acf1a59727258f89a5c4ef958
-  data.tar.gz: c49bc230e812d7b59eb27461481ea6b0b0181c1161f06df6e20161d528ff4a5b
+  metadata.gz: 19c908ad19445dc3ca95af2873ad94c885fd3546de85a78005cf3d45a10c2b7f
+  data.tar.gz: 10fd5fb0daf18cf0eeb466079307eb6f47f913c4e7e1e7031c7d7944beff4cb2
 SHA512:
-  metadata.gz: d40a68ab5d0014a65fa51a4afd3ed7f464cb3a6c3c31df660197de4c6123e61dfd1c40ede9bde91c9c4cf125d89dce725c0b5c3958efad1be669a98e679f23ad
-  data.tar.gz: 1e3f8787982405109068f33b4beff9ca9a9a6860a1069a442bdf09a19f96335997e3a0ba2fe2895a57d7f002f38eaf0217130a7b4dfa44e62b4ea6f7459b019d
+  metadata.gz: 0fca963918760eb442d55982d5de06875ed92293ad58a0d422f095f4e72bf2181ebbdb4ea99bdd978473d860b5f2948d98e92550938df0e7310fd707e94228b2
+  data.tar.gz: 6016bfab349b9b24af874cdf416bbc2dde40e6e106c30ce18157c609d7de418f1935c79d6fe782d75cb3ff03d49385f1c4b93994baf77e5e45aea90b834e3e1c

data/lib/opal/vite/compiler.rb

@@ -1,5 +1,6 @@
 require 'opal'
 require 'json'
+require 'pathname'
 
 module Opal
   module Vite
@@ -38,12 +39,10 @@ module Opal
             dependencies: extract_dependencies(builder)
           }
 
-          # Try to extract source map if available
+          # Extract source map if enabled
           if @config.source_map_enabled
             begin
-              # Opal::Builder should have source map information
-              # Try to get it from the processed assets
-              source_map = extract_source_map(builder)
+              source_map = extract_source_map(builder, file_path)
               result[:map] = source_map if source_map
             rescue => e
               # Source map extraction failed, log but don't fail compilation
@@ -141,26 +140,340 @@ module Opal
         builder.processed.map { |asset| asset.filename }.compact
       end
 
-      def extract_source_map(builder)
-        # Get source map from the builder's processed assets
-        # Opal stores source maps in the compiled assets
-        return nil unless builder.processed.any?
+      def extract_source_map(builder, file_path)
+        # Use builder's combined source_map which includes all compiled files
+        # This allows debugging of all required files (controllers, services, etc.)
+        return nil unless builder.respond_to?(:source_map) && builder.source_map
 
-        # Get the main compiled asset (usually the last one)
-        main_asset = builder.processed.last
-        return nil unless main_asset
+        source_map = builder.source_map
+        map_hash = deep_stringify_keys(source_map.to_h)
+        return nil unless map_hash
 
-        # Check if the asset has source map data
-        if main_asset.respond_to?(:source_map) && main_asset.source_map
-          return main_asset.source_map.to_json
+        # If it's an index format with sections, merge all sections
+        if map_hash['sections']
+          map_hash = merge_all_sections(map_hash, file_path)
         end
 
-        # Try to get from the builder directly
-        if builder.respond_to?(:source_map) && builder.source_map
-          return builder.source_map.to_json
+        return nil unless map_hash
+
+        # Add sourceRoot for proper browser debugging
+        # This helps DevTools organize source files in a logical tree
+        map_hash['sourceRoot'] = ''
+
+        # Normalize source paths for browser debugging
+        # Prefix with /opal-sources/ so they appear in a dedicated folder in DevTools
+        if map_hash['sources']
+          map_hash['sources'] = map_hash['sources'].map do |source|
+            normalize_source_path_for_devtools(source, file_path)
+          end
+        end
+
+        map_hash.to_json
+      end
+
+      # Recursively convert all hash keys to strings
+      def deep_stringify_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(key, value), result|
+            result[key.to_s] = deep_stringify_keys(value)
+          end
+        when Array
+          obj.map { |item| deep_stringify_keys(item) }
+        else
+          obj
+        end
+      end
+
+      def merge_all_sections(index_map, file_path)
+        sections = index_map['sections']
+        return nil if sections.nil? || sections.empty?
+
+        # For single section, just return that section's map
+        if sections.length == 1
+          return sections.first['map']
+        end
+
+        # Merge all sections into a single standard source map
+        # This allows debugging of all files (application.rb + all required files)
+        merged = {
+          'version' => 3,
+          'file' => File.basename(file_path),
+          'sources' => [],
+          'sourcesContent' => [],
+          'names' => [],
+          'mappings' => ''
+        }
+
+        # Track cumulative state for VLQ relative encoding
+        # These track the "previous" values across all sections
+        prev_source = 0
+        prev_orig_line = 0
+        prev_orig_col = 0
+        prev_name = 0
+
+        current_line = 0
+
+        sections.each_with_index do |section, idx|
+          section_map = section['map']
+          next unless section_map
+
+          offset = section['offset'] || { 'line' => 0, 'column' => 0 }
+          section_start_line = offset['line'] || 0
+
+          # Add empty lines to reach the section's starting line
+          lines_to_add = section_start_line - current_line
+          if lines_to_add > 0
+            merged['mappings'] += ';' * lines_to_add
+            current_line = section_start_line
+          end
+
+          # Track source and name index offsets for this section
+          source_offset = merged['sources'].length
+          name_offset = merged['names'].length
+
+          # Add sources and sourcesContent from this section
+          if section_map['sources']
+            section_map['sources'].each_with_index do |source, i|
+              merged['sources'] << source
+              if section_map['sourcesContent'] && section_map['sourcesContent'][i]
+                merged['sourcesContent'] << section_map['sourcesContent'][i]
+              else
+                merged['sourcesContent'] << nil
+              end
+            end
+          end
+
+          # Add names from this section
+          if section_map['names']
+            merged['names'].concat(section_map['names'])
+          end
+
+          # Process mappings from this section with index adjustment
+          if section_map['mappings'] && !section_map['mappings'].empty?
+            adjusted_mappings, prev_source, prev_orig_line, prev_orig_col, prev_name =
+              adjust_section_mappings(
+                section_map['mappings'],
+                source_offset,
+                name_offset,
+                prev_source,
+                prev_orig_line,
+                prev_orig_col,
+                prev_name
+              )
+
+            if idx > 0 && !merged['mappings'].empty? && !merged['mappings'].end_with?(';')
+              merged['mappings'] += ';'
+            end
+            merged['mappings'] += adjusted_mappings
+
+            # Update current_line to the last line we wrote to
+            # section_start_line + number of semicolons in this section's mappings
+            current_line = section_start_line + section_map['mappings'].count(';')
+          end
+        end
+
+        merged
+      end
+
+      # Adjust mappings from a section by adding offsets to source/name indices
+      # VLQ mappings use relative deltas. When merging sections:
+      # - First section: no adjustment, just track final absolute state
+      # - Later sections: adjust first segment's source/name delta to bridge from previous section's end state
+      #
+      # Returns: [adjusted_mappings, new_prev_source, new_prev_orig_line, new_prev_orig_col, new_prev_name]
+      def adjust_section_mappings(mappings, source_offset, name_offset, prev_source, prev_orig_line, prev_orig_col, prev_name)
+        return ['', prev_source, prev_orig_line, prev_orig_col, prev_name] if mappings.nil? || mappings.empty?
+
+        result_lines = []
+        lines = mappings.split(';', -1)
+
+        # Track absolute state within this section (section-local, starting from 0)
+        section_abs_source = 0
+        section_abs_orig_line = 0
+        section_abs_orig_col = 0
+        section_abs_name = 0
+
+        first_segment_processed = false
+
+        lines.each do |line|
+          if line.empty?
+            result_lines << ''
+            next
+          end
+
+          result_segments = []
+          segments = line.split(',')
+
+          segments.each do |segment|
+            values = decode_vlq(segment)
+            next if values.empty?
+
+            # values[0] = generated column delta (always present, relative within line)
+            # values[1] = source index delta
+            # values[2] = original line delta
+            # values[3] = original column delta
+            # values[4] = name index delta
+
+            gen_col_delta = values[0]
+
+            if values.length > 1
+              # Update section-local absolute positions
+              section_abs_source += values[1]
+              section_abs_orig_line += values[2] if values.length > 2
+              section_abs_orig_col += values[3] if values.length > 3
+              section_abs_name += values[4] if values.length > 4
+
+              # Calculate global absolute positions (with offset)
+              global_abs_source = section_abs_source + source_offset
+              global_abs_name = section_abs_name + name_offset
+
+              if !first_segment_processed
+                # First segment: calculate delta from previous section's end state to this segment's global position
+                new_source_delta = global_abs_source - prev_source
+                new_orig_line_delta = section_abs_orig_line - prev_orig_line
+                new_orig_col_delta = section_abs_orig_col - prev_orig_col
+                new_name_delta = global_abs_name - prev_name
+
+                new_values = [gen_col_delta, new_source_delta, new_orig_line_delta, new_orig_col_delta]
+                new_values << new_name_delta if values.length > 4
+
+                first_segment_processed = true
+              else
+                # Subsequent segments: deltas are already correct (relative within section = relative within merged)
+                new_values = values.dup
+              end
+
+              result_segments << encode_vlq(new_values)
+
+              # Update tracking for next section
+              prev_source = global_abs_source
+              prev_orig_line = section_abs_orig_line
+              prev_orig_col = section_abs_orig_col
+              prev_name = global_abs_name if values.length > 4
+            else
+              # Only generated column, no source mapping
+              result_segments << encode_vlq([gen_col_delta])
+            end
+          end
+
+          result_lines << result_segments.join(',')
+        end
+
+        [result_lines.join(';'), prev_source, prev_orig_line, prev_orig_col, prev_name]
+      end
+
+      # VLQ Base64 character set
+      VLQ_BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.freeze
+      VLQ_BASE64_VALUES = VLQ_BASE64_CHARS.each_char.with_index.to_h.freeze
+      VLQ_BASE_SHIFT = 5
+      VLQ_BASE = 1 << VLQ_BASE_SHIFT  # 32
+      VLQ_BASE_MASK = VLQ_BASE - 1     # 31
+      VLQ_CONTINUATION_BIT = VLQ_BASE  # 32
+
+      # Decode a VLQ-encoded segment into an array of integers
+      def decode_vlq(segment)
+        return [] if segment.nil? || segment.empty?
+
+        values = []
+        shift = 0
+        value = 0
+
+        segment.each_char do |char|
+          digit = VLQ_BASE64_VALUES[char]
+          return values if digit.nil?  # Invalid character
+
+          continuation = (digit & VLQ_CONTINUATION_BIT) != 0
+          digit &= VLQ_BASE_MASK
+          value += digit << shift
+
+          if continuation
+            shift += VLQ_BASE_SHIFT
+          else
+            # Convert from VLQ signed representation
+            negative = (value & 1) == 1
+            value >>= 1
+            value = -value if negative
+            values << value
+
+            # Reset for next value
+            value = 0
+            shift = 0
+          end
         end
 
-        nil
+        values
+      end
+
+      # Encode an array of integers into a VLQ-encoded string
+      def encode_vlq(values)
+        return '' if values.nil? || values.empty?
+
+        result = ''
+
+        values.each do |value|
+          # Convert to VLQ signed representation
+          vlq = value < 0 ? ((-value) << 1) + 1 : value << 1
+
+          loop do
+            digit = vlq & VLQ_BASE_MASK
+            vlq >>= VLQ_BASE_SHIFT
+            digit |= VLQ_CONTINUATION_BIT if vlq > 0
+            result += VLQ_BASE64_CHARS[digit]
+            break if vlq == 0
+          end
+        end
+
+        result
+      end
+
+      def normalize_source_path(source, file_path)
+        # Convert absolute paths to relative for better browser debugging
+        return source if source.nil? || source.empty?
+
+        # If source is already relative or a URL, keep it
+        return source unless source.start_with?('/')
+
+        # Try to make path relative to the original file
+        begin
+          Pathname.new(source).relative_path_from(Pathname.new(File.dirname(file_path))).to_s
+        rescue ArgumentError
+          # On different drives/mounts, keep absolute path
+          source
+        end
+      end
+
+      def normalize_source_path_for_devtools(source, file_path)
+        # Format source paths so they appear properly in browser DevTools
+        # Chrome DevTools uses the source path to build the file tree
+        return source if source.nil? || source.empty?
+
+        # Remove any leading ./ for consistency
+        source = source.sub(/^\.\//, '')
+
+        # Handle absolute paths - make them relative to show properly
+        if source.start_with?('/')
+          # Extract just the relevant path (last few components)
+          parts = source.split('/')
+          # Keep last 3 path components for context (e.g., app/opal/controllers/...)
+          source = parts.last(3).join('/')
+        end
+
+        # Prefix paths for user code (controllers, services, etc.) to group them
+        # This ensures they appear under a dedicated folder in DevTools
+        if source.include?('controllers/') || source.include?('services/')
+          # Already has recognizable path, prefix with opal-sources for visibility
+          "/opal-sources/#{source}"
+        elsif source.start_with?('corelib/') || source.start_with?('opal/')
+          # Opal core library files - put under opal-core
+          "/opal-core/#{source}"
+        elsif source.include?('opal_stimulus/') || source.include?('opal_vite/')
+          # Opal library files
+          "/opal-libs/#{source}"
+        else
+          # Other files (native.rb, js/proxy.rb, etc.)
+          "/opal-other/#{source}"
+        end
       end
     end
   end

data/lib/opal/vite/testing/stable_helpers.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+module Opal
+  module Vite
+    module Testing
+      # StableHelpers - JavaScript-based element interaction methods for Capybara
+      # All polling and retry logic runs in JavaScript for reliability
+      # Reduces Ruby ↔ JavaScript communication overhead
+      #
+      # Usage:
+      #   # In spec_helper.rb
+      #   require 'opal/vite/testing/stable_helpers'
+      #
+      #   RSpec.configure do |config|
+      #     config.include Opal::Vite::Testing::StableHelpers, type: :feature
+      #   end
+      #
+      module StableHelpers
+        # Default configuration
+        DEFAULT_TIMEOUT = 10
+        DEFAULT_INTERVAL = 50 # ms (JavaScript side)
+
+        # Wait for element to be present and stable in DOM using JavaScript polling
+        # @param selector [String] CSS selector
+        # @param timeout [Integer] Maximum wait time in seconds
+        # @return [Capybara::Node::Element] The found element
+        def stable_find(selector, timeout: DEFAULT_TIMEOUT, visible: true)
+          js_wait_for_element(selector, timeout: timeout, visible: visible)
+          find(selector, visible: visible, wait: 1)
+        end
+
+        # Find all elements after ensuring DOM stability
+        # @param selector [String] CSS selector
+        # @param timeout [Integer] Maximum wait time in seconds
+        # @return [Array<Capybara::Node::Element>] Found elements
+        def stable_all(selector, timeout: DEFAULT_TIMEOUT)
+          wait_for_dom_stable(timeout: timeout)
+          all(selector, wait: 1)
+        end
+
+        # Click element with retry logic
+        # Uses Capybara native click with JS fallback for reliability
+        # @param selector [String] CSS selector
+        # @param timeout [Integer] Maximum wait time in seconds
+        def stable_click(selector, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          start_time = Time.now
+
+          loop do
+            begin
+              # Use Capybara's find with wait, then click
+              element = find(selector, wait: 2, visible: true)
+              element.click
+              # Small delay to allow event processing
+              sleep(0.05)
+              return true
+            rescue Capybara::ElementNotFound, Ferrum::NodeNotFoundError, Ferrum::TimeoutError,
+                   Capybara::Cuprite::MouseEventFailed => e
+              # If native click fails, try JavaScript click
+              js_clicked = page.evaluate_script(<<~JS)
+                (function() {
+                  var el = document.querySelector('#{escaped_selector}');
+                  if (el && el.offsetParent !== null) {
+                    el.click();
+                    return true;
+                  }
+                  return false;
+                })()
+              JS
+              return true if js_clicked
+
+              elapsed = Time.now - start_time
+              raise e if elapsed > timeout
+              sleep(DEFAULT_INTERVAL / 1000.0)
+            end
+          end
+        end
+
+        # Set value on input with stability check
+        # @param selector [String] CSS selector
+        # @param value [String] Value to set
+        # @param timeout [Integer] Maximum wait time in seconds
+        def stable_set(selector, value, timeout: DEFAULT_TIMEOUT)
+          escaped_value = escape_js(value)
+          js_retry_action(selector, 'set', value: escaped_value, timeout: timeout)
+        end
+
+        # Send keys to element with stability check
+        # @param selector [String] CSS selector
+        # @param keys [Array] Keys to send
+        def stable_send_keys(selector, *keys, timeout: DEFAULT_TIMEOUT)
+          element = stable_find(selector, timeout: timeout)
+          element.native.send_keys(*keys)
+        end
+
+        # Combined set and send_keys for form inputs (common pattern)
+        # Uses JavaScript for value setting, Capybara native for key events
+        # @param selector [String] CSS selector
+        # @param value [String] Value to type
+        # @param submit_key [Symbol] Key to send after value (e.g., :enter)
+        def stable_input(selector, value, submit_key: nil, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          escaped_value = escape_js(value)
+          start_time = Time.now
+
+          loop do
+            # Set value via JavaScript for reliability
+            result = page.evaluate_script(<<~JS)
+              (function() {
+                var el = document.querySelector('#{escaped_selector}');
+                if (!el || el.offsetParent === null) {
+                  return { success: false, reason: 'not_found' };
+                }
+
+                try {
+                  el.focus();
+                  el.value = '#{escaped_value}';
+                  el.dispatchEvent(new Event('input', { bubbles: true }));
+                  el.dispatchEvent(new Event('change', { bubbles: true }));
+
+                  if (el.value !== '#{escaped_value}') {
+                    return { success: false, reason: 'value_not_set' };
+                  }
+
+                  return { success: true };
+                } catch (e) {
+                  return { success: false, reason: e.message };
+                }
+              })()
+            JS
+
+            if result && result['success']
+              # Use Capybara's native send_keys for Enter key (more reliable with Stimulus)
+              if submit_key
+                # Small delay to ensure Stimulus has processed the value change
+                sleep(0.05)
+                element = find(selector)
+                element.native.send_keys(submit_key)
+              end
+              return true
+            end
+
+            elapsed = Time.now - start_time
+            if elapsed > timeout
+              reason = result ? result['reason'] : 'unknown'
+              raise Capybara::ElementNotFound, "stable_input failed on '#{selector}': #{reason}"
+            end
+
+            sleep(DEFAULT_INTERVAL / 1000.0)
+          end
+        end
+
+        # Wait for element count to match expected (all polling in JavaScript)
+        # @param selector [String] CSS selector
+        # @param count [Integer] Expected count
+        # @param timeout [Integer] Maximum wait time in seconds
+        def wait_for_count(selector, count, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          js_poll_until(
+            "document.querySelectorAll('#{escaped_selector}').length === #{count}",
+            timeout: timeout,
+            error_message: "Expected #{count} elements for '#{selector}'"
+          )
+        end
+
+        # Wait for element to contain text
+        # @param selector [String] CSS selector
+        # @param text [String] Text to find
+        # @param timeout [Integer] Maximum wait time in seconds
+        def wait_for_text(selector, text, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          escaped_text = escape_js(text)
+          js_poll_until(
+            "(function() { var el = document.querySelector('#{escaped_selector}'); return el && el.textContent.includes('#{escaped_text}'); })()",
+            timeout: timeout,
+            error_message: "Text '#{text}' not found in '#{selector}'"
+          )
+        end
+
+        # Wait for element to have specific class
+        # @param selector [String] CSS selector
+        # @param class_name [String] CSS class name
+        # @param timeout [Integer] Maximum wait time in seconds
+        def wait_for_class(selector, class_name, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          escaped_class = escape_js(class_name)
+          js_poll_until(
+            "(function() { var el = document.querySelector('#{escaped_selector}'); return el && el.classList.contains('#{escaped_class}'); })()",
+            timeout: timeout,
+            error_message: "Class '#{class_name}' not found on '#{selector}'"
+          )
+        end
+
+        # Wait for element to NOT have specific class
+        # @param selector [String] CSS selector
+        # @param class_name [String] CSS class name
+        # @param timeout [Integer] Maximum wait time in seconds
+        def wait_for_no_class(selector, class_name, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          escaped_class = escape_js(class_name)
+          js_poll_until(
+            "(function() { var el = document.querySelector('#{escaped_selector}'); return el && !el.classList.contains('#{escaped_class}'); })()",
+            timeout: timeout,
+            error_message: "Class '#{class_name}' still present on '#{selector}'"
+          )
+        end
+
+        # Wait for checkbox to be checked
+        # @param selector [String] CSS selector
+        # @param timeout [Integer] Maximum wait time in seconds
+        def wait_for_checked(selector, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          js_poll_until(
+            "(function() { var el = document.querySelector('#{escaped_selector}'); return el && el.checked === true; })()",
+            timeout: timeout,
+            error_message: "Checkbox '#{selector}' not checked"
+          )
+        end
+
+        # Public API for custom JavaScript conditions
+        # @param js_condition [String] JavaScript expression that returns true when ready
+        # @param timeout [Integer] Maximum wait time in seconds
+        def js_wait_for(js_condition, timeout: DEFAULT_TIMEOUT)
+          js_poll_until(js_condition, timeout: timeout, error_message: "Condition not met: #{js_condition}")
+        end
+
+        # Wait for DOM to be stable (no pending mutations)
+        # Uses MutationObserver setup in JS with Ruby-based polling
+        # @param timeout [Integer] Maximum wait time in seconds
+        # @param stability_time [Integer] Time in ms with no changes to consider stable
+        def wait_for_dom_stable(timeout: DEFAULT_TIMEOUT, stability_time: 100)
+          # Setup MutationObserver in JavaScript
+          page.execute_script(<<~JS)
+            window.__domStabilityState = { stable: false, lastChange: Date.now() };
+            if (window.__domObserver) window.__domObserver.disconnect();
+
+            window.__domObserver = new MutationObserver(function() {
+              window.__domStabilityState.stable = false;
+              window.__domStabilityState.lastChange = Date.now();
+            });
+
+            window.__domObserver.observe(document.body, {
+              childList: true,
+              subtree: true,
+              attributes: true
+            });
+          JS
+
+          start_time = Time.now
+
+          # Poll for stability using Ruby loop
+          loop do
+            result = page.evaluate_script(<<~JS)
+              (function() {
+                var state = window.__domStabilityState;
+                if (!state) return { stable: true };
+                var elapsed = Date.now() - state.lastChange;
+                return { stable: elapsed >= #{stability_time}, elapsed: elapsed };
+              })()
+            JS
+
+            if result && result['stable']
+              # Cleanup observer
+              page.execute_script(<<~JS)
+                if (window.__domObserver) {
+                  window.__domObserver.disconnect();
+                  delete window.__domObserver;
+                }
+                delete window.__domStabilityState;
+              JS
+              return true
+            end
+
+            elapsed = Time.now - start_time
+            if elapsed > timeout
+              # Cleanup observer on timeout
+              page.execute_script('if (window.__domObserver) window.__domObserver.disconnect();')
+              raise Capybara::ElementNotFound, 'DOM did not stabilize within timeout'
+            end
+
+            sleep(DEFAULT_INTERVAL / 1000.0)
+          end
+        end
+
+        private
+
+        # Wait for element to be present and visible using JavaScript polling
+        def js_wait_for_element(selector, timeout:, visible:)
+          escaped_selector = escape_js(selector)
+          visibility_check = visible ? ' && el.offsetParent !== null' : ''
+
+          js_poll_until(
+            "(function() { var el = document.querySelector('#{escaped_selector}'); return el !== null#{visibility_check}; })()",
+            timeout: timeout,
+            error_message: "Element not found: #{selector}"
+          )
+        end
+
+        # Wait for input to have specific value
+        def wait_for_value(selector, value, timeout:)
+          escaped_selector = escape_js(selector)
+          escaped_value = escape_js(value)
+          js_poll_until(
+            "(function() { var el = document.querySelector('#{escaped_selector}'); return el && el.value === '#{escaped_value}'; })()",
+            timeout: timeout,
+            error_message: "Value '#{value}' not set on '#{selector}'"
+          )
+        end
+
+        # Core JavaScript polling - all retry logic runs in browser
+        # @param js_condition [String] JavaScript expression that returns true when ready
+        # @param timeout [Integer] Maximum wait time in seconds
+        # @param error_message [String] Error message on timeout
+        def js_poll_until(js_condition, timeout:, error_message: nil)
+          error_msg = error_message || "Condition not met: #{js_condition}"
+
+          # Use synchronous polling with Ruby timeout to avoid async script timeout issues
+          start_time = Time.now
+
+          loop do
+            result = page.evaluate_script(<<~JS)
+              (function() {
+                try {
+                  return #{js_condition} ? true : false;
+                } catch (e) {
+                  return false;
+                }
+              })()
+            JS
+
+            return true if result
+
+            elapsed = Time.now - start_time
+            raise Capybara::ElementNotFound, error_msg if elapsed > timeout
+
+            sleep(DEFAULT_INTERVAL / 1000.0)
+          end
+        end
+
+        # JavaScript-based action with Ruby retry loop (click, set, etc.)
+        # @param selector [String] CSS selector
+        # @param action [String] Action to perform ('click', 'set')
+        # @param value [String] Value for 'set' action
+        # @param timeout [Integer] Maximum wait time in seconds
+        def js_retry_action(selector, action, value: nil, timeout: DEFAULT_TIMEOUT)
+          escaped_selector = escape_js(selector)
+          escaped_value = value ? escape_js(value) : ''
+          start_time = Time.now
+
+          loop do
+            result = page.evaluate_script(<<~JS)
+              (function() {
+                var el = document.querySelector('#{escaped_selector}');
+                if (!el || el.offsetParent === null) {
+                  return { success: false, reason: 'not_found' };
+                }
+
+                try {
+                  if ('#{action}' === 'click') {
+                    el.click();
+                    return { success: true };
+                  } else if ('#{action}' === 'set') {
+                    el.focus();
+                    el.value = '#{escaped_value}';
+                    el.dispatchEvent(new Event('input', { bubbles: true }));
+                    el.dispatchEvent(new Event('change', { bubbles: true }));
+                    return { success: true };
+                  } else {
+                    return { success: false, reason: 'unknown_action' };
+                  }
+                } catch (e) {
+                  return { success: false, reason: e.message };
+                }
+              })()
+            JS
+
+            return true if result && result['success']
+
+            elapsed = Time.now - start_time
+            if elapsed > timeout
+              reason = result ? result['reason'] : 'unknown'
+              raise Capybara::ElementNotFound, "Action '#{action}' failed on '#{selector}': #{reason}"
+            end
+
+            sleep(DEFAULT_INTERVAL / 1000.0)
+          end
+        end
+
+        # Escape string for JavaScript
+        def escape_js(str)
+          str.to_s.gsub('\\', '\\\\\\\\').gsub("'", "\\\\'").gsub("\n", '\\n')
+        end
+      end
+    end
+  end
+end
+
+# Alias for backward compatibility
+StableHelpers = Opal::Vite::Testing::StableHelpers

data/lib/opal/vite/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module Vite
-    VERSION = "0.2.3"
+    VERSION = "0.2.6"
   end
 end

data/lib/opal-vite.rb

@@ -30,12 +30,20 @@ module Opal
       # CLI entry point for compilation
       # @param file_path [String] The path to the Ruby file to compile
       # @param include_concerns [Boolean] Whether to include built-in concerns
-      def compile_for_vite(file_path, include_concerns: true)
+      # @param source_map [Boolean] Whether to generate source maps
+      def compile_for_vite(file_path, include_concerns: true, source_map: true)
+        # Temporarily override source map setting if specified
+        original_source_map = config.source_map_enabled
+        config.source_map_enabled = source_map
+
         compiler = Compiler.new(include_concerns: include_concerns)
         result = compiler.compile_file(file_path)
 
         # Output JSON to stdout for the Vite plugin to consume
         puts JSON.generate(result)
+
+        # Restore original setting
+        config.source_map_enabled = original_source_map
       rescue Compiler::CompilationError => e
         STDERR.puts e.message
         exit 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opal-vite
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.6
 platform: ruby
 authors:
 - stofu1234
@@ -109,6 +109,7 @@ files:
 - lib/opal/vite/compiler.rb
 - lib/opal/vite/config.rb
 - lib/opal/vite/source_map.rb
+- lib/opal/vite/testing/stable_helpers.rb
 - lib/opal/vite/version.rb
 - opal/opal_vite.rb
 - opal/opal_vite/concerns.rb