Download data/web/src/composables/scroll.ts from introvoyz045/CopilotJ: direct link, hf CLI and curl.
- Browser
- Download file 6.26 kB
-
https://huggingface.co/datasets/introvoyz045/CopilotJ/resolve/main/data/web/src/composables/scroll.ts
- Command line
-
hf download hf://datasets/introvoyz045/CopilotJ/data/web/src/composables/scroll.ts
-
curl -L -o scroll.ts https://huggingface.co/datasets/introvoyz045/CopilotJ/resolve/main/data/web/src/composables/scroll.ts
6.26 kB
| /** | |
| * SPDX-FileCopyrightText: Copyright contributors to the CopilotJ project. | |
| * | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import type { MaybeRef } from "vue"; | |
| import { | |
| computed, | |
| isRef, | |
| nextTick, | |
| onActivated, | |
| onDeactivated, | |
| onMounted, | |
| onUnmounted, | |
| ref, | |
| shallowRef, | |
| unref, | |
| watch, | |
| } from "vue"; | |
| type ScrollContainer = HTMLElement | null | undefined; | |
| type UseCustomScrollOptions = { | |
| // top offset: determine "arrived" when approaching threshold | |
| offsetTop?: number; | |
| // bottom offset: determine "arrived" when approaching threshold | |
| offsetBottom?: number; | |
| // behavior of window.scrollTo | |
| behavior?: ScrollBehavior; | |
| // whether event listener is passive (recommended true for performance) | |
| passive?: boolean; | |
| /** | |
| * scroll event throttling: | |
| * - 'raf': merge with requestAnimationFrame | |
| * - number: throttle with timer in milliseconds | |
| * - null: no throttling | |
| */ | |
| throttle?: number | "frame" | null; | |
| // whether to re-measure on ResizeObserver changes | |
| measureOnResize?: boolean; | |
| }; | |
| export function useCustomScroll(containerRef: MaybeRef<ScrollContainer>, options: UseCustomScrollOptions = {}) { | |
| const { | |
| offsetTop = 0, | |
| offsetBottom = 32, | |
| behavior = "smooth", | |
| passive = true, | |
| throttle = "frame", | |
| measureOnResize = true, | |
| } = options; | |
| // state | |
| const y = ref(0); | |
| const prevY = ref(0); | |
| const direction = computed<"up" | "down" | "none">(() => { | |
| if (y.value === prevY.value) return "none"; | |
| return y.value > prevY.value ? "down" : "up"; | |
| }); | |
| const arrivedTop = ref(true); | |
| const arrivedBottom = ref(false); | |
| const isScrolling = ref(false); | |
| const scrollHeight = ref(0); | |
| const clientHeight = ref(0); | |
| // internals | |
| const cleanupFns: Array<() => void> = []; | |
| const ro = shallowRef<ResizeObserver | null>(null); | |
| let ticking = false; | |
| let throttleTimer: number | null = null; | |
| const _measureCore = (el: HTMLElement) => { | |
| const top = el.scrollTop; | |
| prevY.value = y.value; | |
| y.value = top; | |
| scrollHeight.value = el.scrollHeight; | |
| clientHeight.value = el.clientHeight; | |
| arrivedTop.value = top <= offsetTop; | |
| arrivedBottom.value = top + el.clientHeight >= el.scrollHeight - offsetBottom; | |
| }; | |
| const measure = () => { | |
| const el = unref(containerRef); | |
| if (!el) return; | |
| _measureCore(el); | |
| }; | |
| // throttled/frame scroll handler | |
| const handleScroll = () => { | |
| const el = unref(containerRef); | |
| if (!el) return; | |
| if (throttle === "frame") { | |
| if (ticking) return; | |
| ticking = true; | |
| requestAnimationFrame(() => { | |
| _measureCore(el); | |
| ticking = false; | |
| }); | |
| return; | |
| } | |
| if (typeof throttle === "number" && throttle > 0) { | |
| if (throttleTimer != null) return; | |
| throttleTimer = window.setTimeout(() => { | |
| _measureCore(el); | |
| throttleTimer = null; | |
| }, throttle) as unknown as number; | |
| return; | |
| } | |
| _measureCore(el); | |
| }; | |
| // scroll APIs | |
| const scrollTo = (top: number) => { | |
| const el = unref(containerRef); | |
| if (!el) return; | |
| el.scrollTo({ top, behavior }); | |
| }; | |
| const scrollBy = (delta: number) => { | |
| const el = unref(containerRef); | |
| if (!el) return; | |
| el.scrollTo({ | |
| top: el.scrollTop + delta, | |
| behavior, | |
| }); | |
| }; | |
| const scrollToTop = () => scrollTo(0); | |
| const scrollToBottom = () => { | |
| const el = unref(containerRef); | |
| if (!el) return; | |
| el.scrollTo({ | |
| top: el.scrollHeight - el.clientHeight, | |
| behavior, | |
| }); | |
| // To ensure measurement is in post-scroll state, measure in next frame | |
| requestAnimationFrame(measure); | |
| // Additionally: delay once more to accommodate asynchronous content expansion | |
| setTimeout(measure, 0); | |
| setTimeout(measure, 50); | |
| // If you want to leave a bottom offset when scrolling to bottom, you can use: | |
| // el.scrollTo({ top: Math.max(0, el.scrollHeight - el.clientHeight - offsetBottom), behavior }) | |
| }; | |
| // ---- listeners setup/cleanup | |
| const setupScrollListener = (el: HTMLElement) => { | |
| el.addEventListener("scroll", onScroll, { passive: passive ?? true }); | |
| cleanupFns.push(() => el.removeEventListener("scroll", onScroll)); | |
| }; | |
| const onScroll = (evt: Event) => { | |
| isScrolling.value = true; | |
| handleScroll(); | |
| // Reset isScrolling at the end of a macro task, indicating this scroll cycle is complete (approximate) | |
| queueMicrotask(() => { | |
| isScrolling.value = false; | |
| }); | |
| }; | |
| const setupResizeObserver = (el: HTMLElement) => { | |
| if (!("ResizeObserver" in window) || !measureOnResize) return; | |
| const observer = new ResizeObserver(() => { | |
| // Re-measure when container size changes or content reflows | |
| measure(); | |
| }); | |
| observer.observe(el); | |
| ro.value = observer; | |
| cleanupFns.push(() => { | |
| observer.disconnect(); | |
| ro.value = null; | |
| }); | |
| }; | |
| const setup = (el: HTMLElement) => { | |
| setupScrollListener(el); | |
| setupResizeObserver(el); | |
| // Initial measurement: first nextTick wait for DOM stable, then measure + add another frame | |
| nextTick(() => { | |
| measure(); | |
| requestAnimationFrame(measure); | |
| }); | |
| }; | |
| const cleanup = () => { | |
| cleanupFns.splice(0).forEach((fn) => { | |
| try { | |
| fn(); | |
| } catch {} | |
| }); | |
| if (throttleTimer != null) { | |
| clearTimeout(throttleTimer); | |
| throttleTimer = null; | |
| } | |
| ticking = false; | |
| }; | |
| // ---- lifecycle | |
| onMounted(() => { | |
| const el = unref(containerRef); | |
| if (el) setup(el as HTMLElement); | |
| }); | |
| onUnmounted(() => { | |
| cleanup(); | |
| }); | |
| // Support keep-alive: re-measure on activation to avoid inaccurate status due to size/content changes | |
| onActivated(() => { | |
| requestAnimationFrame(measure); | |
| }); | |
| onDeactivated(() => { | |
| // Process as needed | |
| }); | |
| // Rebind when container reference changes | |
| if (isRef(containerRef)) { | |
| watch( | |
| containerRef, | |
| (el, oldEl) => { | |
| if (oldEl) cleanup(); | |
| if (el) setup(el as HTMLElement); | |
| }, | |
| { flush: "post" }, | |
| ); | |
| } | |
| return { | |
| // state | |
| y, | |
| direction, | |
| arrivedTop, | |
| arrivedBottom, | |
| isScrolling, | |
| scrollHeight, | |
| clientHeight, | |
| // actions | |
| measure, | |
| scrollTo, | |
| scrollBy, | |
| scrollToTop, | |
| scrollToBottom, | |
| }; | |
| } | |