diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /testing/web-platform/tests/scroll-animations/view-timelines/sticky | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'testing/web-platform/tests/scroll-animations/view-timelines/sticky')
7 files changed, 858 insertions, 0 deletions
diff --git a/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-1.html b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-1.html new file mode 100644 index 0000000000..d8756769c5 --- /dev/null +++ b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-1.html @@ -0,0 +1,120 @@ +<!DOCTYPE html> +<html id="top"> +<head> +<meta charset="utf-8"> +<title>View timeline with sticky during entry/exit</title> +<link rel="help" href="https://drafts.csswg.org/scroll-animations-1/#viewtimeline-interface"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/web-animations/testcommon.js"></script> +<script src="/scroll-animations/scroll-timelines/testcommon.js"></script> +<script src="/scroll-animations/view-timelines/testcommon.js"></script> +<style> + +#container { + height: 500px; + overflow: auto; +} +.space { + height: 550px; +} + +/* top-sticky during entry */ +.stickycase1 { + background: yellow; + position: sticky; + top: 400px; + height: 200px; +} + +#target { + position: relative; + top: 50px; + background: orange; + height: 100px; +} + +</style> +</head> +<body> +<div id="container"> + <div class="space"></div> + <div class="space"> + <div style="height: 150px"></div> + <div id="sticky" class="stickycase1"> + <div id="target">Subject</div> + </div> + </div> + <div class="space"></div> +</div> +<script type="text/javascript"> + +// The "cover" range would be [STATIC_START, STATIC_END] if we ignored +// stickiness (i.e., considered only static position). +// +// STATIC_START = scroll distance to second spacer (50px) +// + position of sticky element within its container (150px) +// + position of target within sticky element (50px) +// STATIC_END = STATIC_START +// + viewport height (500px) +// + target height (100px) +const STATIC_START = 250; +const STATIC_END = 850; + +// This is how far the sticky element can move upwards when bottom-stuck. +const ROOM_ABOVE = 150; + +// This is how far the sticky element can move downwards when top-stuck. +const ROOM_BELOW = 200; + +const TARGET_HEIGHT = 100; +const VIEWPORT_HEIGHT = 500; + +promise_test(async t => { + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'cover', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'cover', offset: CSS.percent(100) }, + startOffset: STATIC_START, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'contain', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'contain', offset: CSS.percent(100) }, + startOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry', offset: CSS.percent(100) }, + startOffset: STATIC_START, + endOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START, + endOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit', offset: CSS.percent(100) }, + startOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); +}, 'View timeline top-sticky during entry.'); + +</script> +</body> +</html> diff --git a/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-2.html b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-2.html new file mode 100644 index 0000000000..2d098dcbe3 --- /dev/null +++ b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-2.html @@ -0,0 +1,121 @@ +<!DOCTYPE html> +<html id="top"> +<head> +<meta charset="utf-8"> +<title>View timeline with sticky during entry/exit</title> +<link rel="help" href="https://drafts.csswg.org/scroll-animations-1/#viewtimeline-interface"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/web-animations/testcommon.js"></script> +<script src="/scroll-animations/scroll-timelines/testcommon.js"></script> +<script src="/scroll-animations/view-timelines/testcommon.js"></script> +<style> + +#container { + height: 500px; + overflow: auto; +} +.space { + height: 550px; +} + +/* bottom-sticky during entry and top-sticky during exit */ +.stickycase2 { + background: yellow; + position: sticky; + top: -100px; + bottom: -100px; + height: 200px; +} + +#target { + position: relative; + top: 50px; + background: orange; + height: 100px; +} + +</style> +</head> +<body> +<div id="container"> + <div class="space"></div> + <div class="space"> + <div style="height: 150px"></div> + <div id="sticky" class="stickycase2"> + <div id="target">Subject</div> + </div> + </div> + <div class="space"></div> +</div> +<script type="text/javascript"> + +// The "cover" range would be [STATIC_START, STATIC_END] if we ignored +// stickiness (i.e., considered only static position). +// +// STATIC_START = scroll distance to second spacer (50px) +// + position of sticky element within its container (150px) +// + position of target within sticky element (50px) +// STATIC_END = STATIC_START +// + viewport height (500px) +// + target height (100px) +const STATIC_START = 250; +const STATIC_END = 850; + +// This is how far the sticky element can move upwards when bottom-stuck. +const ROOM_ABOVE = 150; + +// This is how far the sticky element can move downwards when top-stuck. +const ROOM_BELOW = 200; + +const TARGET_HEIGHT = 100; +const VIEWPORT_HEIGHT = 500; + +promise_test(async t => { + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'cover', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'cover', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'contain', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'contain', offset: CSS.percent(100) }, + startOffset: STATIC_START + TARGET_HEIGHT, + endOffset: STATIC_END - TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_START + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_START + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit', offset: CSS.percent(100) }, + startOffset: STATIC_END - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_END - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); +}, 'View timeline bottom-sticky during entry and top-sticky during exit.'); + +</script> +</body> +</html> diff --git a/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-3.html b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-3.html new file mode 100644 index 0000000000..c87dfc4dcb --- /dev/null +++ b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-3.html @@ -0,0 +1,121 @@ +<!DOCTYPE html> +<html id="top"> +<head> +<meta charset="utf-8"> +<title>View timeline with sticky during entry/exit</title> +<link rel="help" href="https://drafts.csswg.org/scroll-animations-1/#viewtimeline-interface"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/web-animations/testcommon.js"></script> +<script src="/scroll-animations/scroll-timelines/testcommon.js"></script> +<script src="/scroll-animations/view-timelines/testcommon.js"></script> +<style> + +#container { + height: 500px; + overflow: auto; +} +.space { + height: 550px; +} + +/* top-sticky and bottom-sticky during entry */ +.stickycase3 { + background: yellow; + position: sticky; + top: 375px; + bottom: -125px; + height: 200px; +} + +#target { + position: relative; + top: 50px; + background: orange; + height: 100px; +} + +</style> +</head> +<body> +<div id="container"> + <div class="space"></div> + <div class="space"> + <div style="height: 150px"></div> + <div id="sticky" class="stickycase3"> + <div id="target">Subject</div> + </div> + </div> + <div class="space"></div> +</div> +<script type="text/javascript"> + +// The "cover" range would be [STATIC_START, STATIC_END] if we ignored +// stickiness (i.e., considered only static position). +// +// STATIC_START = scroll distance to second spacer (50px) +// + position of sticky element within its container (150px) +// + position of target within sticky element (50px) +// STATIC_END = STATIC_START +// + viewport height (500px) +// + target height (100px) +const STATIC_START = 250; +const STATIC_END = 850; + +// This is how far the sticky element can move upwards when bottom-stuck. +const ROOM_ABOVE = 150; + +// This is how far the sticky element can move downwards when top-stuck. +const ROOM_BELOW = 200; + +const TARGET_HEIGHT = 100; +const VIEWPORT_HEIGHT = 500; + +promise_test(async t => { + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'cover', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'cover', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'contain', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'contain', offset: CSS.percent(100) }, + startOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit', offset: CSS.percent(100) }, + startOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); +}, 'View timeline top-sticky and bottom-sticky during entry.'); + +</script> +</body> +</html> diff --git a/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-4.html b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-4.html new file mode 100644 index 0000000000..f6b02ffb2e --- /dev/null +++ b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-4.html @@ -0,0 +1,120 @@ +<!DOCTYPE html> +<html id="top"> +<head> +<meta charset="utf-8"> +<title>View timeline with sticky during entry/exit</title> +<link rel="help" href="https://drafts.csswg.org/scroll-animations-1/#viewtimeline-interface"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/web-animations/testcommon.js"></script> +<script src="/scroll-animations/scroll-timelines/testcommon.js"></script> +<script src="/scroll-animations/view-timelines/testcommon.js"></script> +<style> + +#container { + height: 500px; + overflow: auto; +} +.space { + height: 550px; +} + +/* top-sticky before entry */ +.stickycase4 { + background: yellow; + position: sticky; + top: 600px; + height: 200px; +} + +#target { + position: relative; + top: 50px; + background: orange; + height: 100px; +} + +</style> +</head> +<body> +<div id="container"> + <div class="space"></div> + <div class="space"> + <div style="height: 150px"></div> + <div id="sticky" class="stickycase4"> + <div id="target">Subject</div> + </div> + </div> + <div class="space"></div> +</div> +<script type="text/javascript"> + +// The "cover" range would be [STATIC_START, STATIC_END] if we ignored +// stickiness (i.e., considered only static position). +// +// STATIC_START = scroll distance to second spacer (50px) +// + position of sticky element within its container (150px) +// + position of target within sticky element (50px) +// STATIC_END = STATIC_START +// + viewport height (500px) +// + target height (100px) +const STATIC_START = 250; +const STATIC_END = 850; + +// This is how far the sticky element can move upwards when bottom-stuck. +const ROOM_ABOVE = 150; + +// This is how far the sticky element can move downwards when top-stuck. +const ROOM_BELOW = 200; + +const TARGET_HEIGHT = 100; +const VIEWPORT_HEIGHT = 500; + +promise_test(async t => { + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'cover', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'cover', offset: CSS.percent(100) }, + startOffset: STATIC_START + ROOM_BELOW, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'contain', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'contain', offset: CSS.percent(100) }, + startOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry', offset: CSS.percent(100) }, + startOffset: STATIC_START + ROOM_BELOW, + endOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START + ROOM_BELOW, + endOffset: STATIC_START + ROOM_BELOW + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit', offset: CSS.percent(100) }, + startOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_END + ROOM_BELOW - TARGET_HEIGHT, + endOffset: STATIC_END + ROOM_BELOW, + axis: 'block' + }); +}, 'View timeline top-sticky before entry.'); + +</script> +</body> +</html> diff --git a/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-5.html b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-5.html new file mode 100644 index 0000000000..380c01297e --- /dev/null +++ b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-5.html @@ -0,0 +1,121 @@ +<!DOCTYPE html> +<html id="top"> +<head> +<meta charset="utf-8"> +<title>View timeline with sticky during entry/exit</title> +<link rel="help" href="https://drafts.csswg.org/scroll-animations-1/#viewtimeline-interface"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/web-animations/testcommon.js"></script> +<script src="/scroll-animations/scroll-timelines/testcommon.js"></script> +<script src="/scroll-animations/view-timelines/testcommon.js"></script> +<style> + +#container { + height: 500px; + overflow: auto; +} +.space { + height: 550px; +} + +/* bottom-sticky before entry and top-sticky after exit */ +.stickycase5 { + background: yellow; + position: sticky; + top: -200px; + bottom: -200px; + height: 200px; +} + +#target { + position: relative; + top: 50px; + background: orange; + height: 100px; +} + +</style> +</head> +<body> +<div id="container"> + <div class="space"></div> + <div class="space"> + <div style="height: 150px"></div> + <div id="sticky" class="stickycase5"> + <div id="target">Subject</div> + </div> + </div> + <div class="space"></div> +</div> +<script type="text/javascript"> + +// The "cover" range would be [STATIC_START, STATIC_END] if we ignored +// stickiness (i.e., considered only static position). +// +// STATIC_START = scroll distance to second spacer (50px) +// + position of sticky element within its container (150px) +// + position of target within sticky element (50px) +// STATIC_END = STATIC_START +// + viewport height (500px) +// + target height (100px) +const STATIC_START = 250; +const STATIC_END = 850; + +// This is how far the sticky element can move upwards when bottom-stuck. +const ROOM_ABOVE = 150; + +// This is how far the sticky element can move downwards when top-stuck. +const ROOM_BELOW = 200; + +const TARGET_HEIGHT = 100; +const VIEWPORT_HEIGHT = 500; + +promise_test(async t => { + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'cover', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'cover', offset: CSS.percent(100) }, + startOffset: STATIC_START, + endOffset: STATIC_END, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'contain', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'contain', offset: CSS.percent(100) }, + startOffset: STATIC_START + TARGET_HEIGHT, + endOffset: STATIC_END - TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry', offset: CSS.percent(100) }, + startOffset: STATIC_START, + endOffset: STATIC_START + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START, + endOffset: STATIC_START + TARGET_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit', offset: CSS.percent(100) }, + startOffset: STATIC_END - TARGET_HEIGHT, + endOffset: STATIC_END, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_END - TARGET_HEIGHT, + endOffset: STATIC_END, + axis: 'block' + }); +}, 'View timeline bottom-sticky before entry and top-sticky after exit.'); + +</script> +</body> +</html> diff --git a/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-6.html b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-6.html new file mode 100644 index 0000000000..94f0abc9b1 --- /dev/null +++ b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-6.html @@ -0,0 +1,127 @@ +<!DOCTYPE html> +<html id="top"> +<head> +<meta charset="utf-8"> +<title>View timeline with sticky during entry/exit</title> +<link rel="help" href="https://drafts.csswg.org/scroll-animations-1/#viewtimeline-interface"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/web-animations/testcommon.js"></script> +<script src="/scroll-animations/scroll-timelines/testcommon.js"></script> +<script src="/scroll-animations/view-timelines/testcommon.js"></script> +<style> + +#container { + height: 500px; + overflow: auto; +} +.space { + height: 550px; +} + +/* target > viewport, bottom-sticky during entry and top-sticky during exit */ +.stickycase6 { + background: yellow; + position: sticky; + top: -200px; + bottom: -200px; + height: 700px; +} + +#target { + position: relative; + top: 50px; + background: orange; + height: 600px; +} + +.space:has(.stickycase6), +.space:has(.stickycase7) { + height: 1050px; +} + +</style> +</head> +<body> +<div id="container"> + <div class="space"></div> + <div class="space"> + <div style="height: 150px"></div> + <div id="sticky" class="stickycase6"> + <div id="target">Subject</div> + </div> + </div> + <div class="space"></div> +</div> +<script type="text/javascript"> + +// The "cover" range would be [STATIC_START, STATIC_END] if we ignored +// stickiness (i.e., considered only static position). +// +// STATIC_START = scroll distance to second spacer (50px) +// + position of sticky element within its container (150px) +// + position of target within sticky element (50px) +// STATIC_END = STATIC_START +// + viewport height (500px) +// + target height (100px) +const STATIC_START = 250; +const BIG_TARGET_STATIC_END = 1350; + +// This is how far the sticky element can move upwards when bottom-stuck. +const ROOM_ABOVE = 150; + +// This is how far the sticky element can move downwards when top-stuck. +const ROOM_BELOW = 200; + +const BIG_TARGET_HEIGHT = 600; +const VIEWPORT_HEIGHT = 500; + +promise_test(async t => { + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'cover', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'cover', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'contain', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'contain', offset: CSS.percent(100) }, + startOffset: STATIC_START + VIEWPORT_HEIGHT, + endOffset: BIG_TARGET_STATIC_END - VIEWPORT_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_START + VIEWPORT_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: BIG_TARGET_STATIC_END - VIEWPORT_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit', offset: CSS.percent(100) }, + startOffset: BIG_TARGET_STATIC_END - VIEWPORT_HEIGHT, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START + VIEWPORT_HEIGHT, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW, + axis: 'block' + }); +}, 'View timeline target > viewport, ' + + 'bottom-sticky during entry and top-sticky during exit.'); + +</script> +</body> +</html> diff --git a/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-7.html b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-7.html new file mode 100644 index 0000000000..83115249fa --- /dev/null +++ b/testing/web-platform/tests/scroll-animations/view-timelines/sticky/view-timeline-sticky-offscreen-7.html @@ -0,0 +1,128 @@ +<!DOCTYPE html> +<html id="top"> +<head> +<meta charset="utf-8"> +<title>View timeline with sticky during entry/exit</title> +<link rel="help" href="https://drafts.csswg.org/scroll-animations-1/#viewtimeline-interface"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/web-animations/testcommon.js"></script> +<script src="/scroll-animations/scroll-timelines/testcommon.js"></script> +<script src="/scroll-animations/view-timelines/testcommon.js"></script> +<style> + +#container { + height: 500px; + overflow: auto; +} +.space { + height: 550px; +} + +/* target > viewport, bottom-sticky and top-sticky during contain */ +.stickycase7 { + background: yellow; + position: sticky; + top: -100px; + bottom: -100px; + height: 700px; +} + +#target { + position: relative; + top: 50px; + background: orange; + height: 600px; +} + +.space:has(.stickycase6), +.space:has(.stickycase7) { + height: 1050px; +} + +</style> +</head> +<body> +<div id="container"> + <div class="space"></div> + <div class="space"> + <div style="height: 150px"></div> + <div id="sticky" class="stickycase7"> + <div id="target">Subject</div> + </div> + </div> + <div class="space"></div> +</div> +<script type="text/javascript"> + +// The "cover" range would be [STATIC_START, STATIC_END] if we ignored +// stickiness (i.e., considered only static position). +// +// STATIC_START = scroll distance to second spacer (50px) +// + position of sticky element within its container (150px) +// + position of target within sticky element (50px) +// STATIC_END = STATIC_START +// + viewport height (500px) +// + target height (100px) +const STATIC_START = 250; +const BIG_TARGET_STATIC_END = 1350; + +// This is how far the sticky element can move upwards when bottom-stuck. +const ROOM_ABOVE = 150; + +// This is how far the sticky element can move downwards when top-stuck. +const ROOM_BELOW = 200; + +const BIG_TARGET_HEIGHT = 600; +const VIEWPORT_HEIGHT = 500; + +promise_test(async t => { + sticky.className = "stickycase7"; + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'cover', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'cover', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'contain', offset: CSS.percent(0) } , + rangeEnd: { rangeName: 'contain', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE + VIEWPORT_HEIGHT, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW - VIEWPORT_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: STATIC_START - ROOM_ABOVE + VIEWPORT_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'entry-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'entry-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW - VIEWPORT_HEIGHT, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit', offset: CSS.percent(100) }, + startOffset: BIG_TARGET_STATIC_END + ROOM_BELOW - VIEWPORT_HEIGHT, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW, + axis: 'block' + }); + await runTimelineRangeTest(t, { + rangeStart: { rangeName: 'exit-crossing', offset: CSS.percent(0) }, + rangeEnd: { rangeName: 'exit-crossing', offset: CSS.percent(100) }, + startOffset: STATIC_START - ROOM_ABOVE + VIEWPORT_HEIGHT, + endOffset: BIG_TARGET_STATIC_END + ROOM_BELOW, + axis: 'block' + }); +}, 'View timeline target > viewport, ' + + 'bottom-sticky and top-sticky during contain.'); + +</script> +</body> +</html> |