Title: Browser layout expert: detect content hidden in scroll regions (5 h, hourly)

$25-50 USD / hour

Posted 1 minute ago

•

Ends in 6 days

$25-50 USD / hour

About the project A test harness that renders React components in headless Chromium, changes their content and screen size, and measures whether the layout breaks. Breakage is found by geometry, not by comparing screenshots: five checks run inside the page and report overflow, clipping, content spilling out of its box, overlap and content cut off by the screen edge. The checks have been compared against blind human labels. The problem The checks treat every scroll container as fine, because content past its edge can be reached by scrolling. Human labellers disagree in one kind of case: a navigation row that scrolls with its scroll bar hidden by CSS, and at 200% text size shrinks until only "Dashb" of its first link shows. The screenshots show no scroll bars at all, so the rule has to come from the page's DOM and CSS, not from the picture. The current checks are frozen, so this is a prototype rule for the next version. What you'll do Must have: 1. Define, in plain words first, and then implement a new check for scroll regions that hide content without any sign that they scroll: either the scroll bar is hidden by CSS, or the visible area has shrunk smaller than a single item. 2. Put the check behind a switch, so that with the switch off nothing in the current results changes. 3. Pin its behaviour with lab cases (minimal HTML with exact expected counts, both cases it must flag and cases it must not): left-to-right and right-to-left pages, horizontal and vertical scrolling, nested scroll containers, scroll bars hidden in each common way, and regions that are cut off but do show that they scroll. If time is left: 4. Content pushed past a scroll container's start edge (for example centred content wider than its container), which cannot be scrolled to at all. 5. A badge or pill that runs under neighbouring text that sits in no box. Acceptance (I will run these) - Switch off: the full test suite passes, and no existing check's output changes. - Switch on: - your lab cases pass; - none of the 20 hand-written reference components gets a finding in any of the 19 test cases; - the real component from the disagreement above fails its case; - three real cases whose scroll region is already cut in the unchanged render get no new failure. - Checks stay plain DOM functions: no timers, no randomness, no network. Deliverables 1. Commits in the repository I give you (Conventional Commits format, no trailers), sent back as patch files. You don't push anywhere. 2. A short, factual report of about one page (400 to 600 words), as plain text or Markdown, covering: - the rule in plain words, as it would read in documentation, and the severity you suggest (error or info); - what it catches and what it misses, naming the lab cases that show each; - the acceptance results: each command you ran, pass or fail, and the key numbers; - anything you did differently from this brief, and why; - open questions or risks, and the hours spent. No screenshots or slides needed. Clarity matters more than polish. Skills required - Deep knowledge of how Chromium lays out a page: overflow and scroll containers, flexbox and grid alignment, right-to-left text and scroll bar styling. This matters more than any library. The checks are plain browser code (getComputedStyle, getBoundingClientRect, [login to view URL]) with no framework. - TypeScript, React, Vite and Playwright (Chromium only). - Tailwind CSS v4: the components being tested are styled with Tailwind classes, so you need to read what those classes produce. - Node.js 26 and its built-in test runner (node --test). Node runs the TypeScript files directly; there is no Jest or Vitest. - Git, to send your commits back as patch files. Nothing else is needed: no backend, database, cloud service or API key. Terms Hourly at [rate], capped at 5 hours. Must-haves first; if you reach the cap, stop and report where you are. Scripts must keep working on Windows, macOS and Linux. I share the code after the award, and all communication stays on Freelancer. To apply, answer in your own words 1. Screenshots in this harness show no scroll bars. From inside the page, how would you tell whether a scroll container's scroll bar is hidden by CSS, both with `scrollbar-width: none` and with a `::-webkit-scrollbar` rule? 2. An `overflow-x: auto` container holds a flex row with `justify-content: center` that is wider than the container. What can the user scroll to, and what can't they? 3. Your plan for the 5 hours, in a few lines.

Project ID: 40825994

About the project

60 proposals

Open for bidding

Remote project

Active 2 secs ago

Place your bid

Bid amount Email address

Benefits of bidding on Freelancer

Set your budget and timeframe

It's free to sign up and bid on jobs

60 freelancers are bidding on average $31 USD/hour for this job

User Avatar
Flag of BANGLADESH

Browser layout debugging is central to my frontend development work, with strong HTML, CSS and JavaScript skills for inspecting how content behaves across real viewport and overflow conditions. This project’s DOM-based approach—using computed styles, element geometry and rendered content rather than screenshots—aligns directly with that experience. My background in web development includes troubleshooting responsive layouts, CSS overflow, clipping, scrolling and content visibility issues across modern websites and applications. I can work within the existing TypeScript/React/Playwright harness, keep the prototype isolated behind a switch, and contribute focused lab coverage for horizontal and vertical scrolling, RTL layouts, nested containers and hidden scrollbar styles. I also understand the importance of preserving existing outputs when the feature is disabled and delivering clean Git patches with clear Conventional Commits. I can provide the requested plain-language rule, implementation, regression cases and concise acceptance report within the capped scope. Choose me to investigate this browser-layout edge case with careful attention to geometry, CSS behavior and non-regression.

User Avatar
Flag of PAKISTAN

Hello, I can contribute to this browser-layout harness by implementing the gated DOM check, focused lab cases, and the requested factual report. I would inspect computed overflow and scrollbar styles, including scrollbar-width and ::-webkit-scrollbar rules, while validating scrollable extents, directionality, nested regions, and centered overflow behavior. I will preserve existing outputs when disabled and use the repository’s TypeScript, Playwright, and Node test conventions. A useful improvement is to keep diagnostic reasons separate from finding counts for easier review. How is the feature switch currently represented in the test harness? Check out my portfolio here:- https://www.freelancer.com/u/installerpoint Best Regards, Muhammad Adeel

User Avatar
Flag of PAKISTAN

Hello, I can help prototype this DOM/CSS-based scroll-region check within the five-hour cap. I’ll first document the rule, then implement it behind a feature switch while preserving current results when disabled. I’ll add focused Node test cases covering LTR/RTL, horizontal and vertical scrolling, nested containers, hidden scrollbar techniques, and visibly scrollable clipped regions. I’ll also validate the reference components and report exact commands, outcomes, counts, limitations, and time spent. The implementation will stay framework-independent, using computed styles, geometry, and range rectangles, with conventional commits and patch files suitable for Windows, macOS, and Linux. I’ll prioritize the required behavior before optional start-edge handling or overlap detection. Regards Muhammad

User Avatar
Flag of PAKISTAN

Hi there, To catch the unreadable navigation row without changing trusted results, I can add a switchable DOM check that flags scroll regions whose content is cut off and whose scrolling is not apparent. I’ll define the rule in plain language before implementing it. Inside Chromium, I’d confirm that content actually overflows, then inspect computed `scrollbar-width` for `none` and the computed `::-webkit-scrollbar` style for `display: none` or a zero-sized scrollbar. I’d also check whether the visible region is narrower than a single item. I won’t infer hidden scrollbars from screenshots or assume an overlay scrollbar is hidden by CSS. With an oversized, centred flex row, the user can scroll toward the end edge, but content protruding past the start edge can remain unreachable: the left edge in LTR, the right edge in RTL. I’ll first establish the switch-off baseline, then implement and test the rule with LTR/RTL, both axes, nested containers, hidden-scrollbar styles and visible-scroll controls. Next I’ll run the reference and real-component acceptance cases, address any false positives, and return Conventional Commit patches plus the requested factual report. I’ll keep the optional checks separate and stop at the cap if necessary. Please share the repository so I can inspect the existing check interface and test commands.

User Avatar
Flag of INDIA

Hi, I’d inspect computed styles and overflow geometry inside the page: detect scroll containers via `overflow`, `scrollWidth/clientWidth`, then check whether scrollbar suppression is explicit (`scrollbar-width: none`, `::-webkit-scrollbar { display: none; width: 0; height: 0; }`) and whether the visible box is smaller than a single child/item. I’d add the new rule behind a feature switch, keep current checks unchanged when off, and cover LTR/RTL, horizontal/vertical, nested, hidden-scrollbar, and non-scrollable-cutoff cases with exact lab fixtures. In your flex-row example, the user can scroll to centered content that lies within the scrollable range, but cannot reach content pushed past the container’s start edge if it never enters the scrollable area. Plan: first map the existing geometry checks and switch plumbing, then implement the new DOM/CSS rule, then add lab cases and run the full acceptance suite, fixing edge cases as needed. Start the chat so we can discuss it further. Regards, Sai Bhaskar

User Avatar
Flag of PAKISTAN

Hi, I understand you need a switchable DOM check that detects scroll regions hiding content, without changing existing results when disabled. I would first write the rule in plain words, then inspect computed overflow, scrollbar CSS, scroll dimensions, item rectangles, direction, and nested containers. I would add focused lab cases for both writing directions, scroll axes, hidden scrollbar styles, and visible scrolling, then run the existing suite and record exact results in the report. A hidden scrollbar can be detected from computed scrollbar styles and the WebKit scrollbar rule; geometry and scroll dimensions can confirm whether content is actually unreachable. With centered content wider than its box, the middle area is reachable, while the overflowing start side may be unreachable. My strongest listed skills are JavaScript and HTML; please confirm the repository setup for the required TypeScript, React, Vite, and Playwright work before starting. Could you share one reference component and the current switch/configuration point so I can preserve existing output exactly? ביצ Please start the chat and let’s discuss the test cases and five-hour plan.

User Avatar
Flag of PAKISTAN

Hello, I can help prototype the DOM-based scroll-region check and preserve existing behavior behind a feature switch. My approach would inspect computed overflow and scrollbar styling, compare scroll dimensions with item or visible-region geometry, and cover LTR/RTL, horizontal/vertical, nested, and intentionally scrollable cases with Node’s built-in test runner and Playwright Chromium. For CSS-hidden scrollbars, I would inspect computed scrollbar-width and generated ::-webkit-scrollbar styling, while validating actual scrollability and geometry rather than relying on screenshots. A centered oversized flex row can generally scroll toward its end, but content extending before the scroll origin may remain unreachable. I would reserve time for implementation, lab cases, acceptance runs, and the factual report, stopping at five hours with patch files and Conventional Commits. Regards, Khursheed

User Avatar
Flag of TURKEY

Hi there, I noticed the need to implement a new check for scroll containers that can hide content without showing any scroll indication. My plan would be to first define this behavior clearly in meticulous language, and then carry that into programming the functionality. I have extensive experience with React components and CSS practices that would ensure robust handling of various container styles, ensuring that all edge cases, such as hidden scroll bars or restricted visibility, are covered in the checks. After defining the new criteria, I’d set up a comprehensive suite of lab tests to validate its functioning, ensuring it can handle all specified scenarios including diverse scrolling behaviors and text directions. This would involve creating clear lab cases, as you require. I’m prepared to deliver reliable commits as per your requirements along with a concise report summarizing the outcomes. Looking forward to discussing this further and finalizing the approach together. Regards, Ali

User Avatar
Flag of ROMANIA

Hi, I’ve read your project description and understand that you need a prototype DOM-based check for scroll regions that hide content, protected by a switch and covered with focused lab cases. I can help you achieve this with a careful TypeScript/React/CSS implementation. My experience includes React, Node.js, HTML5, CSS, JavaScript, TypeScript, and frontend debugging. I focus on clear communication, attention to detail, and preserving existing behavior. For hidden scrollbars, I would inspect the container’s computed `scrollbar-width` for `none`, and inspect `getComputedStyle(element, '::-webkit-scrollbar')` for rules such as `display: none` or zero dimensions. For a centered overflowing flex row, content extending past the start edge can be unreachable because scroll position cannot move before the scroll origin; content toward the end remains reachable through scrolling (with RTL handled explicitly). My approach: - Review the current geometry checks and feature-switch pattern. - Define the rule in plain language, then implement it as a plain DOM function. - Add minimal LTR/RTL, horizontal/vertical, nested-container and scrollbar-style lab cases. - Run the available tests and provide Conventional Commit patch files plus the requested factual report. In the 5-hour cap, I would prioritize the must-haves: understand the harness, implement the gated rule, add representative cases, run tests, then document results.

User Avatar
Flag of SERBIA

Hi, I've spent years debugging layout issues in headless browsers and know the DOM and CSS properties you need to inspect here—getComputedStyle for scrollbar visibility, getClientRects to measure what's actually reachable. I understand the core problem: your current checks assume hidden scroll bars mean content is accessible, but when the viewport shrinks below a single item's size or the bar is hidden by CSS, that assumption breaks. I'll start by defining the rule plainly—a scroll container fails if it hides overflow without any visual scroll indicator and the visible area is too small to show a complete item—then implement it as a gated check that leaves existing results untouched. I'll build lab cases covering scrollbar-width: none and ::-webkit-scrollbar rules, horizontal and vertical scrolling, RTL pages, and nested containers, testing each against the harness to confirm they pass or fail as expected. If time remains, I'll tackle content pushed past the start edge that can't be scrolled to at all. The acceptance criteria are clear: switch off produces no change, switch on passes your lab cases and the real component from the disagreement, and stays pure DOM with no side effects. I'll send commits as patch files and a one-page report covering the rule, what it catches and misses, acceptance results, and any deviations or open questions. I can start immediately and stay available for clarification after delivery.

User Avatar
Flag of TANZANIA, UNITED REPUBLIC OF

Hello, The sticky part here is not detecting overflow itself. Your current checks correctly treat scroll containers as fine when content past the edge is reachable. The disagreement case is different: a nav row that still scrolls, but CSS hides every sign of it, and at large text size the visible strip shrinks until only a stump like "Dashb" shows. Humans call that broken even though geometry says scrollable. I would ship a switch-gated rule that flags scroll regions where content is clipped and there is no honest scroll signal, either because the bar is suppressed or because the visible area is smaller than a single item. On scrollbar hiding: for scrollbar-width: none I read getComputedStyle on the element. For ::-webkit-scrollbar I check whether a matching rule collapses the bar (width or height to 0) while scrollWidth or scrollHeight still exceeds the client size. That stays inside the page, no screenshot reading. On the centred flex row in overflow-x: auto: the user can scroll the overhang past the end edge, but the part that sticks out past the start edge is unreachable. That is exactly the optional case I would pick up if hours remain. Five-hour plan: draft the plain-language rule and minimal lab cases (LTR and RTL, nested, hidden bars, honest scrollers), implement b...

User Avatar
Flag of MEXICO

Hi, Fernando from Mexico here. The important distinction here is that scrollability does not always mean content is genuinely accessible. A container may technically allow scrolling while its CSS hides every visual indication, leaving users with content they cannot reasonably discover. I'd approach this as a DOM geometry and computed-style problem, not a screenshot comparison. I'd inspect overflow dimensions, scrollbar styling, visible item geometry and scroll direction, while accounting for RTL layouts, nested containers and partially clipped content. For your 5-hour cap, I'd prioritize defining the rule, implementing it behind a feature switch, and building the requested lab cases with exact expected counts. Then I'd run the existing suite and reference components to check for regressions. If time permits, I'll investigate the start-edge clipping and badge overlap cases. I'll preserve existing results with the switch off and provide Conventional Commit patches plus the factual acceptance report you requested. Fernando

User Avatar
Flag of INDIA

Hello, I HAVE EXPERIENCE IN TYPESCRIPT, JAVASCRIPT, REACT, CHROMIUM BROWSER LAYOUT, DOM GEOMETRY AND PLAYWRIGHT TESTING. I understand you need a new DOM-based check to detect scroll containers that silently hide content, without changing the existing checks or their results when the feature switch is disabled. My approach would be to inspect computed scrollbar styles, scroll dimensions and element geometry, then evaluate whether content is genuinely accessible through scrolling. I would also cover RTL layouts, nested containers, horizontal and vertical scrolling, and visible versus hidden scrollbars. Detecting hidden scrollbars: For scrollbar-width: none, I would inspect the computed scrollbarWidth property. For ::-webkit-scrollbar, I would inspect the pseudo-element's computed styles and dimensions using getComputedStyle(element, '::-webkit-scrollbar'), while accounting for browser-specific behavior. Centered flex row wider than its container: With centered overflowing content, the browser's scrollable range may be asymmetric. Depending on direction and layout, content extending beyond the start edge may be unreachable, while content extending beyond the end edge can be reached by scrolling. I would verify the actual scroll range and geometry rather than assume all overflow is accessible. Thanks, Jitendra

User Avatar
Flag of AUSTRALIA

Hello, I’d approach this by making the new rule purely DOM/CSS based, so it stays reliable in headless Chromium and doesn’t depend on screenshots. For the hidden-scrollbar case, I’d inspect computed styles and the rendered box: `scrollbar-width: none` is straightforward in Firefox-style CSS, and for Chromium I’d look for `::-webkit-scrollbar { display: none; }`/zero-sized scrollbar styling on the scroll container, then combine that with geometry to detect when visible content is actually being clipped with no visible scroll affordance. For your second question: in an `overflow-x: auto` container, a centered flex row wider than the container can still scroll only within the scrollable overflow area. But if the content is pushed past the start edge, the user may not be able to scroll to the hidden leading side at all. I’ve built similar geometry-based layout checks before, including overflow rules for nested scroll regions and RTL cases, so this kind of prototype fits my recent work well. Plan: first pin down the rule in plain words, then add the switch, then cover LTR/RTL, horizontal/vertical, nested scroll containers, and hidden scrollbar variants with minimal lab cases. If time remains, I’d add the “start-edge cut off” and badge/pill edge case. A couple of quick questions: do you want the new rule to be classified as error or info, and is there an existing conventions file for the lab-case naming? Can we have a call? Best regards, Mehreen

User Avatar
Flag of SERBIA

I can implement this as a focused, switch-gated Chromium check without disturbing the frozen results, because layout bugs are mischievous enough already. 1. I would inspect computed overflow, scroll dimensions, client dimensions, scrollbar styling, and pseudo-element rules. `scrollbar-width: none` is directly observable through computed style; for WebKit rules, I would inspect the relevant `::-webkit-scrollbar` computed styles and combine that with scrollability and geometry rather than relying on screenshots. The rule should only flag content when scrolling has no visible affordance, or when the viewport is narrower than a single item. 2. With a centered oversized flex row, the scrollable range may expose the end side, but centered overflow can extend beyond the start edge and become unreachable. I would explicitly test both LTR and RTL behavior rather than assuming `scrollLeft` tells the whole story. 3. I would spend the five hours in this order: map the existing check architecture and switch pattern; document and implement the plain DOM rule; add compact lab cases for directions, axes, nesting, scrollbar-hiding techniques, and visible scrolling; run the full Node/Chromium suite; then prepare Conventional Commits and patch files plus the factual 400-600-word report. I’ll keep the implementation deterministic, framework-independent, and cross-platform. The key design goal is conservative detection: catch genuinely hidden content while avoiding false positives for intenti

User Avatar
Flag of VIETNAM

⭐⭐⭐⭐⭐ Hi there, Is my understanding correct that you need a feature-gated DOM check for visually hidden or unusable scroll regions, plus focused lab cases and a factual report? The key challenge is distinguishing intentional scrollable content from content users cannot discover, while preserving every existing result when the switch is off. RTL, nested containers, flex alignment, and both browser scrollbar-hiding patterns need careful handling. My listed background is AI product development with Python, and I’m comfortable adapting to a clearly scoped browser-code task while learning the repository’s exact TypeScript and test conventions. ❓ Which switch or configuration pattern should the new check follow? ❓ Can you provide the repository and the current reference command before implementation? I’ll focus on DOM geometry, computed styles, scroll metrics, and deterministic cases; I’m ready to begin immediately and will stop cleanly at the five-hour cap. I hope to receive your reply so we can discuss the repository details and approach. Best regards, Phuong Nam D

User Avatar
Flag of PAKISTAN

Greetings! For question one, from inside the page I would read getComputedStyle on the scroll container and check whether scrollbar-width is none, and separately look for a matched ::-webkit-scrollbar rule with zero width or display none, then confirm the element is actually a scroll container via overflow values and scrollWidth or scrollHeight exceeding clientWidth or clientHeight. For question two, with overflow-x auto, a flex row wider than its container using justify-content center, the user can scroll toward the overflowing end in the inline direction but cannot scroll to content pushed past the start edge, since centered overflow spills equally both ways yet scroll offset cannot go negative, so the leading part is unreachable and clipped. My plan for the five hours: first define and implement the hidden-scroll-region check behind a switch, then pin behaviour with lab cases covering left-to-right and right-to-left, horizontal and vertical, nested containers and common hidden scroll bar methods, verify the switch-off suite is unchanged and the switch-on acceptance cases pass, and finally write the one-page factual report, leaving any remaining time for the extra start-edge and badge rules. Thanks, Revival

User Avatar
Flag of VIETNAM

$=== SUPER MATCH ===$ The key is detecting scroll regions that technically allow scrolling but hide that capability so completely that users cannot discover or access the content. I’ll first define the rule precisely, then implement it as an independent DOM-based check behind a feature switch, preserving all existing results when disabled. I’ll build minimal lab cases covering hidden scrollbar techniques, undersized visible areas, RTL/LTR layouts, vertical and horizontal scrolling, nested containers, and legitimate scrollable regions. I’ll also validate against the existing reference components and acceptance suite, recording exact commands, results, edge cases, and limitations. Changes will use Conventional Commits, with patch files and the requested factual report. I’ll keep the implementation deterministic and free of timers, randomness, and network calls. Can you confirm the repository language, test command, and expected switch configuration? Looking forward to working with you.

User Avatar
Flag of CANADA

Hello. I understand you need a new DOM-based check to catch scroll regions that hide content with no visible scroll affordance, and I'd focus first on distinguishing CSS-hidden scrollbars from truly visible ones, since that determines the rule's core logic. I'd inspect scrollbar visibility via computed style and layout metrics (e.g., `scrollbar-width`, `::-webkit-scrollbar` effects, client vs. offset dimensions), implement the check behind a feature flag, and verify it against your lab cases and reference components using the existing Plain DOM test runner. Q1: Should the severity be `info` or `error` for hidden-scroll cases, or do you want the rule to output a suggested severity for now? Happy to review the current check framework and implement a pragmatic prototype within the 5-hour cap.

User Avatar
Flag of THAILAND

I’ve built React and TypeScript interfaces with responsive component behavior, including layout-focused UI work. For this project, the key is a DOM-only rule based on computed overflow, scroll dimensions, geometry, and resolved scrollbar styling, because screenshots cannot reveal hidden affordances. For `scrollbar-width: none`, I’d inspect the computed property; for `::-webkit-scrollbar`, I’d inspect applicable stylesheet rules and their computed pseudo-element style where Chromium exposes it. A centered oversized flex row can scroll toward the overflow on the end side, but content displaced beyond its start edge isn’t reachable. In five hours, I’ll document the rule, add it behind a default-off switch, create focused LTR/RTL and nested lab cases, run the supplied commands, and return Conventional Commit patch files plus the factual report. Thanks, Kittipong

内容来自 Freelancer News,版权归原作者所有。

阅读原文 ↗

用 HomepageTab 新标签页关注 RSS,打开浏览器就能看到更新。

安装 HomepageTab