@fairyhunter13/opentui-core 0.1.112 → 0.1.114

package/src/renderables/ScrollBox.ts

@@ -0,0 +1,883 @@
+import { type KeyEvent } from "../lib/index.js"
+import { getObjectsInViewport } from "../lib/objects-in-viewport.js"
+import { LinearScrollAccel, MacOSScrollAccel, type ScrollAcceleration } from "../lib/scroll-acceleration.js"
+import type { Renderable, RenderableOptions } from "../Renderable.js"
+import type { MouseEvent } from "../renderer.js"
+import type { RenderContext } from "../types.js"
+import { BoxRenderable, type BoxOptions } from "./Box.js"
+import type { VNode } from "./composition/vnode.js"
+import { ScrollBarRenderable, type ScrollBarOptions, type ScrollUnit } from "./ScrollBar.js"
+
+class ContentRenderable extends BoxRenderable {
+  private viewport: BoxRenderable
+  private _viewportCulling: boolean
+
+  constructor(
+    ctx: RenderContext,
+    viewport: BoxRenderable,
+    viewportCulling: boolean,
+    options: RenderableOptions<BoxRenderable>,
+  ) {
+    super(ctx, options)
+    this.viewport = viewport
+    this._viewportCulling = viewportCulling
+  }
+
+  get viewportCulling(): boolean {
+    return this._viewportCulling
+  }
+
+  set viewportCulling(value: boolean) {
+    this._viewportCulling = value
+  }
+
+  protected override _getVisibleChildren(): number[] {
+    if (this._viewportCulling) {
+      return getObjectsInViewport(this.viewport, this.getChildrenSortedByPrimaryAxis(), this.primaryAxis, 0).map(
+        (child) => child.num,
+      )
+    }
+    return this.getChildrenSortedByPrimaryAxis().map((child) => child.num)
+  }
+}
+
+export interface ScrollBoxOptions extends BoxOptions<ScrollBoxRenderable> {
+  rootOptions?: BoxOptions
+  wrapperOptions?: BoxOptions
+  viewportOptions?: BoxOptions
+  contentOptions?: BoxOptions
+  scrollbarOptions?: Omit<ScrollBarOptions, "orientation">
+  verticalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">
+  horizontalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">
+  stickyScroll?: boolean
+  stickyStart?: "bottom" | "top" | "left" | "right"
+  scrollX?: boolean
+  scrollY?: boolean
+  scrollAcceleration?: ScrollAcceleration
+  viewportCulling?: boolean
+}
+
+const SCROLLBOX_PADDING_KEYS = [
+  "padding",
+  "paddingX",
+  "paddingY",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+] as const
+
+type ScrollBoxPaddingKey = (typeof SCROLLBOX_PADDING_KEYS)[number]
+type ScrollBoxPaddingOptions = Pick<ScrollBoxOptions, ScrollBoxPaddingKey>
+
+function pickScrollBoxPadding(options: Partial<ScrollBoxOptions> | undefined): Partial<ScrollBoxPaddingOptions> {
+  if (!options) return {}
+
+  const picked: Partial<ScrollBoxPaddingOptions> = {}
+  for (const key of SCROLLBOX_PADDING_KEYS) {
+    const value = options[key]
+    if (value !== undefined) {
+      picked[key] = value
+    }
+  }
+
+  return picked
+}
+
+function stripScrollBoxPadding<T extends object>(options: T): Omit<T, ScrollBoxPaddingKey> {
+  const sanitized = { ...options }
+  for (const key of SCROLLBOX_PADDING_KEYS) {
+    delete (sanitized as Partial<Record<ScrollBoxPaddingKey, unknown>>)[key]
+  }
+  return sanitized as Omit<T, ScrollBoxPaddingKey>
+}
+
+export class ScrollBoxRenderable extends BoxRenderable {
+  static idCounter = 0
+  private internalId = 0
+  public readonly wrapper: BoxRenderable
+  public readonly viewport: BoxRenderable
+  public readonly content: ContentRenderable
+  public readonly horizontalScrollBar: ScrollBarRenderable
+  public readonly verticalScrollBar: ScrollBarRenderable
+
+  protected override _focusable: boolean = true
+  private selectionListener?: () => void
+
+  private autoScrollMouseX: number = 0
+  private autoScrollMouseY: number = 0
+  private readonly autoScrollThresholdVertical = 3
+  private readonly autoScrollThresholdHorizontal = 3
+  private readonly autoScrollSpeedSlow = 6
+  private readonly autoScrollSpeedMedium = 36
+  private readonly autoScrollSpeedFast = 72
+  private isAutoScrolling: boolean = false
+  private cachedAutoScrollSpeed: number = 3
+  private autoScrollAccumulatorX: number = 0
+  private autoScrollAccumulatorY: number = 0
+
+  private scrollAccumulatorX: number = 0
+  private scrollAccumulatorY: number = 0
+
+  private _stickyScroll: boolean
+  private _stickyScrollTop: boolean = false
+  private _stickyScrollBottom: boolean = false
+  private _stickyScrollLeft: boolean = false
+  private _stickyScrollRight: boolean = false
+  private _stickyStart?: "bottom" | "top" | "left" | "right"
+  private _hasManualScroll: boolean = false
+  private _isApplyingStickyScroll: boolean = false
+  private scrollAccel: ScrollAcceleration
+
+  get stickyScroll(): boolean {
+    return this._stickyScroll
+  }
+
+  set stickyScroll(value: boolean) {
+    this._stickyScroll = value
+    this.updateStickyState()
+  }
+
+  get stickyStart(): "bottom" | "top" | "left" | "right" | undefined {
+    return this._stickyStart
+  }
+
+  set stickyStart(value: "bottom" | "top" | "left" | "right" | undefined) {
+    this._stickyStart = value
+    this.updateStickyState()
+  }
+
+  get scrollTop(): number {
+    return this.verticalScrollBar.scrollPosition
+  }
+
+  set scrollTop(value: number) {
+    this.verticalScrollBar.scrollPosition = value
+    if (!this._isApplyingStickyScroll) {
+      // Only mark as manual scroll if:
+      // 1. We're not at a sticky position after scrolling (prevents programmatic scrolls to sticky edges from disabling sticky)
+      // 2. There's actually meaningful scrollable content (prevents accidental scrolls when content is smaller than viewport from disabling sticky)
+      // Use a small threshold (>1) to account for rounding/layout quirks
+      const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height)
+      if (!this.isAtStickyPosition() && maxScrollTop > 1) {
+        this._hasManualScroll = true
+      }
+    }
+    this.updateStickyState()
+  }
+
+  get scrollLeft(): number {
+    return this.horizontalScrollBar.scrollPosition
+  }
+
+  set scrollLeft(value: number) {
+    this.horizontalScrollBar.scrollPosition = value
+    if (!this._isApplyingStickyScroll) {
+      // Only mark as manual scroll if:
+      // 1. We're not at a sticky position after scrolling (prevents programmatic scrolls to sticky edges from disabling sticky)
+      // 2. There's actually meaningful scrollable content (prevents accidental scrolls when content is smaller than viewport from disabling sticky)
+      // Use a small threshold (>1) to account for rounding/layout quirks
+      const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width)
+      if (!this.isAtStickyPosition() && maxScrollLeft > 1) {
+        this._hasManualScroll = true
+      }
+    }
+    this.updateStickyState()
+  }
+
+  get scrollWidth(): number {
+    return this.horizontalScrollBar.scrollSize
+  }
+
+  get scrollHeight(): number {
+    return this.verticalScrollBar.scrollSize
+  }
+
+  private updateStickyState(): void {
+    if (!this._stickyScroll) return
+
+    const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height)
+    const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width)
+
+    if (this.scrollTop <= 0) {
+      this._stickyScrollTop = true
+      this._stickyScrollBottom = false
+      if (
+        !this._isApplyingStickyScroll &&
+        (this._stickyStart === "top" || (this._stickyStart === "bottom" && maxScrollTop === 0))
+      ) {
+        this._hasManualScroll = false
+      }
+    } else if (this.scrollTop >= maxScrollTop) {
+      this._stickyScrollTop = false
+      this._stickyScrollBottom = true
+      if (!this._isApplyingStickyScroll && this._stickyStart === "bottom") {
+        this._hasManualScroll = false
+      }
+    } else {
+      this._stickyScrollTop = false
+      this._stickyScrollBottom = false
+    }
+
+    if (this.scrollLeft <= 0) {
+      this._stickyScrollLeft = true
+      this._stickyScrollRight = false
+      if (
+        !this._isApplyingStickyScroll &&
+        (this._stickyStart === "left" || (this._stickyStart === "right" && maxScrollLeft === 0))
+      ) {
+        this._hasManualScroll = false
+      }
+    } else if (this.scrollLeft >= maxScrollLeft) {
+      this._stickyScrollLeft = false
+      this._stickyScrollRight = true
+      if (!this._isApplyingStickyScroll && this._stickyStart === "right") {
+        this._hasManualScroll = false
+      }
+    } else {
+      this._stickyScrollLeft = false
+      this._stickyScrollRight = false
+    }
+  }
+
+  private applyStickyStart(stickyStart: "bottom" | "top" | "left" | "right"): void {
+    const wasApplyingStickyScroll = this._isApplyingStickyScroll
+    this._isApplyingStickyScroll = true
+    try {
+      switch (stickyStart) {
+        case "top":
+          this._stickyScrollTop = true
+          this._stickyScrollBottom = false
+          this.verticalScrollBar.scrollPosition = 0
+          break
+        case "bottom":
+          this._stickyScrollTop = false
+          this._stickyScrollBottom = true
+          this.verticalScrollBar.scrollPosition = Math.max(0, this.scrollHeight - this.viewport.height)
+          break
+        case "left":
+          this._stickyScrollLeft = true
+          this._stickyScrollRight = false
+          this.horizontalScrollBar.scrollPosition = 0
+          break
+        case "right":
+          this._stickyScrollLeft = false
+          this._stickyScrollRight = true
+          this.horizontalScrollBar.scrollPosition = Math.max(0, this.scrollWidth - this.viewport.width)
+          break
+      }
+    } finally {
+      this._isApplyingStickyScroll = wasApplyingStickyScroll
+    }
+  }
+
+  constructor(ctx: RenderContext, options: ScrollBoxOptions) {
+    const {
+      wrapperOptions,
+      viewportOptions,
+      contentOptions,
+      rootOptions,
+      scrollbarOptions,
+      verticalScrollbarOptions,
+      horizontalScrollbarOptions,
+      stickyScroll = false,
+      stickyStart,
+      scrollX = false,
+      scrollY = true,
+      scrollAcceleration,
+      viewportCulling = true,
+      ...rootBoxOptions
+    } = options
+
+    const forwardedContentPadding = {
+      ...pickScrollBoxPadding(rootBoxOptions),
+      ...pickScrollBoxPadding(rootOptions),
+    }
+
+    const sanitizedRootBoxOptions = stripScrollBoxPadding(rootBoxOptions)
+    const sanitizedRootOptions = rootOptions ? stripScrollBoxPadding(rootOptions) : undefined
+    const mergedContentOptions = {
+      ...forwardedContentPadding,
+      ...contentOptions,
+    }
+
+    // Root
+    super(ctx, {
+      flexDirection: "row",
+      alignItems: "stretch",
+      ...(sanitizedRootBoxOptions as BoxOptions),
+      ...(sanitizedRootOptions as BoxOptions),
+    })
+
+    this.internalId = ScrollBoxRenderable.idCounter++
+    this._stickyScroll = stickyScroll
+    this._stickyStart = stickyStart
+    this.scrollAccel = scrollAcceleration ?? new LinearScrollAccel()
+
+    this.wrapper = new BoxRenderable(ctx, {
+      flexDirection: "column",
+      flexGrow: 1,
+      ...wrapperOptions,
+      id: `scroll-box-wrapper-${this.internalId}`,
+    })
+    super.add(this.wrapper)
+
+    this.viewport = new BoxRenderable(ctx, {
+      flexDirection: "column",
+      flexGrow: 1,
+      // NOTE: Overflow scroll makes the content size behave weird
+      // when the scrollbox is in a container with max-width/height
+      overflow: "hidden",
+      onSizeChange: () => {
+        this.recalculateBarProps()
+      },
+      ...viewportOptions,
+      id: `scroll-box-viewport-${this.internalId}`,
+    })
+    this.wrapper.add(this.viewport)
+
+    this.content = new ContentRenderable(ctx, this.viewport, viewportCulling, {
+      alignSelf: "flex-start",
+      flexShrink: 0,
+      ...(scrollX ? { minWidth: "100%" } : { minWidth: "100%", maxWidth: "100%" }),
+      ...(scrollY ? { minHeight: "100%" } : { minHeight: "100%", maxHeight: "100%" }),
+      onSizeChange: () => {
+        this.recalculateBarProps()
+      },
+      ...mergedContentOptions,
+      id: `scroll-box-content-${this.internalId}`,
+    })
+    this.viewport.add(this.content)
+
+    this.verticalScrollBar = new ScrollBarRenderable(ctx, {
+      ...scrollbarOptions,
+      ...verticalScrollbarOptions,
+      arrowOptions: {
+        ...scrollbarOptions?.arrowOptions,
+        ...verticalScrollbarOptions?.arrowOptions,
+      },
+      id: `scroll-box-vertical-scrollbar-${this.internalId}`,
+      orientation: "vertical",
+      onChange: (position) => {
+        this.content.translateY = -position
+        if (!this._isApplyingStickyScroll) {
+          // Only mark as manual scroll if we're not at a sticky position and there's meaningful scrollable content
+          const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height)
+          if (!this.isAtStickyPosition() && maxScrollTop > 1) {
+            this._hasManualScroll = true
+          }
+        }
+        this.updateStickyState()
+      },
+    })
+    super.add(this.verticalScrollBar)
+
+    this.horizontalScrollBar = new ScrollBarRenderable(ctx, {
+      ...scrollbarOptions,
+      ...horizontalScrollbarOptions,
+      arrowOptions: {
+        ...scrollbarOptions?.arrowOptions,
+        ...horizontalScrollbarOptions?.arrowOptions,
+      },
+      id: `scroll-box-horizontal-scrollbar-${this.internalId}`,
+      orientation: "horizontal",
+      onChange: (position) => {
+        this.content.translateX = -position
+        if (!this._isApplyingStickyScroll) {
+          // Only mark as manual scroll if we're not at a sticky position and there's meaningful scrollable content
+          const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width)
+          if (!this.isAtStickyPosition() && maxScrollLeft > 1) {
+            this._hasManualScroll = true
+          }
+        }
+        this.updateStickyState()
+      },
+    })
+    this.wrapper.add(this.horizontalScrollBar)
+
+    this.recalculateBarProps()
+
+    if (stickyStart && stickyScroll) {
+      this.applyStickyStart(stickyStart)
+    }
+
+    this.selectionListener = () => {
+      const selection = this._ctx.getSelection()
+      if (!selection || !selection.isDragging) {
+        this.stopAutoScroll()
+      }
+    }
+    this._ctx.on("selection", this.selectionListener)
+  }
+
+  protected override onUpdate(deltaTime: number): void {
+    this.handleAutoScroll(deltaTime)
+  }
+
+  public scrollBy(delta: number | { x: number; y: number }, unit: ScrollUnit = "absolute"): void {
+    if (typeof delta === "number") {
+      this.verticalScrollBar.scrollBy(delta, unit)
+    } else {
+      this.verticalScrollBar.scrollBy(delta.y, unit)
+      this.horizontalScrollBar.scrollBy(delta.x, unit)
+    }
+    // Note: scrollBy doesn't need to set _hasManualScroll here because the scrollbar
+    // change will trigger the scrollTop setter which handles it
+  }
+
+  public scrollChildIntoView(childId: string): void {
+    const child = this.content.findDescendantById(childId)
+    if (!child) return
+
+    const getNearestDelta = (
+      elementStart: number,
+      elementEnd: number,
+      viewportStart: number,
+      viewportEnd: number,
+    ): number => {
+      const elementSize = elementEnd - elementStart
+      const viewportSize = viewportEnd - viewportStart
+      const elementStartOutside = elementStart < viewportStart
+      const elementEndOutside = elementEnd > viewportEnd
+
+      if (elementStartOutside && elementEndOutside) {
+        return 0
+      }
+
+      if ((elementStartOutside && elementSize < viewportSize) || (elementEndOutside && elementSize > viewportSize)) {
+        return elementStart - viewportStart
+      }
+
+      if ((elementStartOutside && elementSize > viewportSize) || (elementEndOutside && elementSize < viewportSize)) {
+        return elementEnd - viewportEnd
+      }
+
+      return 0
+    }
+
+    const childTop = child.y
+    const childBottom = child.y + child.height
+    const viewportTop = this.viewport.y
+    const viewportBottom = this.viewport.y + this.viewport.height
+
+    const dy = getNearestDelta(childTop, childBottom, viewportTop, viewportBottom)
+
+    const childLeft = child.x
+    const childRight = child.x + child.width
+    const viewportLeft = this.viewport.x
+    const viewportRight = this.viewport.x + this.viewport.width
+
+    const dx = getNearestDelta(childLeft, childRight, viewportLeft, viewportRight)
+
+    if (dx !== 0 || dy !== 0) {
+      this.scrollBy({ x: dx, y: dy })
+    }
+  }
+
+  public scrollTo(position: number | { x: number; y: number }): void {
+    if (typeof position === "number") {
+      this.scrollTop = position
+    } else {
+      this.scrollTop = position.y
+      this.scrollLeft = position.x
+    }
+    // Note: scrollTo doesn't need to set _hasManualScroll here because
+    // the scrollTop/scrollLeft setters handle it
+  }
+
+  private isAtStickyPosition(): boolean {
+    if (!this._stickyScroll || !this._stickyStart) {
+      return false
+    }
+
+    const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height)
+    const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width)
+
+    switch (this._stickyStart) {
+      case "top":
+        return this.scrollTop === 0
+      case "bottom":
+        return this.scrollTop >= maxScrollTop
+      case "left":
+        return this.scrollLeft === 0
+      case "right":
+        return this.scrollLeft >= maxScrollLeft
+      default:
+        return false
+    }
+  }
+
+  public override add(obj: Renderable | VNode<any, any[]>, index?: number): number {
+    return this.content.add(obj, index)
+  }
+
+  public override insertBefore(obj: Renderable | VNode<any, any[]> | unknown, anchor?: Renderable | unknown): number {
+    return this.content.insertBefore(obj, anchor)
+  }
+
+  public override remove(id: string): void {
+    this.content.remove(id)
+  }
+
+  public override getChildren(): Renderable[] {
+    return this.content.getChildren()
+  }
+
+  protected override onMouseEvent(event: MouseEvent): void {
+    if (event.type === "scroll") {
+      let dir = event.scroll?.direction
+      if (event.modifiers.shift)
+        dir = dir === "up" ? "left" : dir === "down" ? "right" : dir === "right" ? "down" : "up"
+
+      const baseDelta = event.scroll?.delta ?? 0
+      const now = Date.now()
+      const multiplier = this.scrollAccel.tick(now)
+      const scrollAmount = baseDelta * multiplier
+
+      if (dir === "up") {
+        this.scrollAccumulatorY -= scrollAmount
+        const integerScroll = Math.trunc(this.scrollAccumulatorY)
+        if (integerScroll !== 0) {
+          this.scrollTop += integerScroll
+          this.scrollAccumulatorY -= integerScroll
+        }
+      } else if (dir === "down") {
+        this.scrollAccumulatorY += scrollAmount
+        const integerScroll = Math.trunc(this.scrollAccumulatorY)
+        if (integerScroll !== 0) {
+          this.scrollTop += integerScroll
+          this.scrollAccumulatorY -= integerScroll
+        }
+      } else if (dir === "left") {
+        this.scrollAccumulatorX -= scrollAmount
+        const integerScroll = Math.trunc(this.scrollAccumulatorX)
+        if (integerScroll !== 0) {
+          this.scrollLeft += integerScroll
+          this.scrollAccumulatorX -= integerScroll
+        }
+      } else if (dir === "right") {
+        this.scrollAccumulatorX += scrollAmount
+        const integerScroll = Math.trunc(this.scrollAccumulatorX)
+        if (integerScroll !== 0) {
+          this.scrollLeft += integerScroll
+          this.scrollAccumulatorX -= integerScroll
+        }
+      }
+
+      // Only mark as manual scroll if there's meaningful scrollable content
+      const maxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height)
+      const maxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width)
+      if (maxScrollTop > 1 || maxScrollLeft > 1) {
+        this._hasManualScroll = true
+      }
+    }
+
+    if (event.type === "drag" && event.isDragging) {
+      this.updateAutoScroll(event.x, event.y)
+    } else if (event.type === "up") {
+      this.stopAutoScroll()
+    }
+  }
+
+  public handleKeyPress(key: KeyEvent): boolean {
+    // Let scrollbars handle their own acceleration
+    if (this.verticalScrollBar.handleKeyPress(key)) {
+      this._hasManualScroll = true
+      this.scrollAccel.reset()
+      this.resetScrollAccumulators()
+      return true
+    }
+    if (this.horizontalScrollBar.handleKeyPress(key)) {
+      this._hasManualScroll = true
+      this.scrollAccel.reset()
+      this.resetScrollAccumulators()
+      return true
+    }
+    return false
+  }
+
+  private resetScrollAccumulators(): void {
+    this.scrollAccumulatorX = 0
+    this.scrollAccumulatorY = 0
+  }
+
+  public startAutoScroll(mouseX: number, mouseY: number): void {
+    this.stopAutoScroll()
+    this.autoScrollMouseX = mouseX
+    this.autoScrollMouseY = mouseY
+    this.cachedAutoScrollSpeed = this.getAutoScrollSpeed(mouseX, mouseY)
+    this.isAutoScrolling = true
+
+    if (!this.live) {
+      this.live = true
+    }
+  }
+
+  public updateAutoScroll(mouseX: number, mouseY: number): void {
+    this.autoScrollMouseX = mouseX
+    this.autoScrollMouseY = mouseY
+
+    // Cache the speed based on current mouse position
+    this.cachedAutoScrollSpeed = this.getAutoScrollSpeed(mouseX, mouseY)
+
+    const scrollX = this.getAutoScrollDirectionX(mouseX)
+    const scrollY = this.getAutoScrollDirectionY(mouseY)
+
+    if (scrollX === 0 && scrollY === 0) {
+      this.stopAutoScroll()
+    } else if (!this.isAutoScrolling) {
+      this.startAutoScroll(mouseX, mouseY)
+    }
+  }
+
+  public stopAutoScroll(): void {
+    const wasAutoScrolling = this.isAutoScrolling
+    this.isAutoScrolling = false
+    this.autoScrollAccumulatorX = 0
+    this.autoScrollAccumulatorY = 0
+
+    // Only turn off live if no other features need it
+    // For now, auto-scroll is the only feature using live, but this could be extended
+    if (wasAutoScrolling && !this.hasOtherLiveReasons()) {
+      this.live = false
+    }
+  }
+
+  private hasOtherLiveReasons(): boolean {
+    // Placeholder for future features that might need live mode
+    // For now, always return false since auto-scroll is the only user
+    return false
+  }
+
+  private handleAutoScroll(deltaTime: number): void {
+    if (!this.isAutoScrolling) return
+
+    const scrollX = this.getAutoScrollDirectionX(this.autoScrollMouseX)
+    const scrollY = this.getAutoScrollDirectionY(this.autoScrollMouseY)
+    const scrollAmount = this.cachedAutoScrollSpeed * (deltaTime / 1000)
+
+    let scrolled = false
+
+    if (scrollX !== 0) {
+      this.autoScrollAccumulatorX += scrollX * scrollAmount
+      const integerScrollX = Math.trunc(this.autoScrollAccumulatorX)
+      if (integerScrollX !== 0) {
+        this.scrollLeft += integerScrollX
+        this.autoScrollAccumulatorX -= integerScrollX
+        scrolled = true
+      }
+    }
+
+    if (scrollY !== 0) {
+      this.autoScrollAccumulatorY += scrollY * scrollAmount
+      const integerScrollY = Math.trunc(this.autoScrollAccumulatorY)
+      if (integerScrollY !== 0) {
+        this.scrollTop += integerScrollY
+        this.autoScrollAccumulatorY -= integerScrollY
+        scrolled = true
+      }
+    }
+
+    if (scrolled) {
+      this._ctx.requestSelectionUpdate()
+    }
+
+    if (scrollX === 0 && scrollY === 0) {
+      this.stopAutoScroll()
+    }
+  }
+
+  private getAutoScrollDirectionX(mouseX: number): number {
+    const relativeX = mouseX - this.x
+    const distToLeft = relativeX
+    const distToRight = this.width - relativeX
+
+    if (distToLeft <= this.autoScrollThresholdHorizontal) {
+      return this.scrollLeft > 0 ? -1 : 0
+    } else if (distToRight <= this.autoScrollThresholdHorizontal) {
+      const maxScrollLeft = this.scrollWidth - this.viewport.width
+      return this.scrollLeft < maxScrollLeft ? 1 : 0
+    }
+    return 0
+  }
+
+  private getAutoScrollDirectionY(mouseY: number): number {
+    const relativeY = mouseY - this.y
+    const distToTop = relativeY
+    const distToBottom = this.height - relativeY
+
+    if (distToTop <= this.autoScrollThresholdVertical) {
+      return this.scrollTop > 0 ? -1 : 0
+    } else if (distToBottom <= this.autoScrollThresholdVertical) {
+      const maxScrollTop = this.scrollHeight - this.viewport.height
+      return this.scrollTop < maxScrollTop ? 1 : 0
+    }
+    return 0
+  }
+
+  private getAutoScrollSpeed(mouseX: number, mouseY: number): number {
+    const relativeX = mouseX - this.x
+    const relativeY = mouseY - this.y
+
+    const distToLeft = relativeX
+    const distToRight = this.width - relativeX
+    const distToTop = relativeY
+    const distToBottom = this.height - relativeY
+
+    const minDistance = Math.min(distToLeft, distToRight, distToTop, distToBottom)
+
+    if (minDistance <= 1) {
+      return this.autoScrollSpeedFast
+    } else if (minDistance <= 2) {
+      return this.autoScrollSpeedMedium
+    } else {
+      return this.autoScrollSpeedSlow
+    }
+  }
+
+  private recalculateBarProps(): void {
+    // Wrap entire method to prevent scroll changes from being treated as manual
+    const wasApplyingStickyScroll = this._isApplyingStickyScroll
+    this._isApplyingStickyScroll = true
+
+    try {
+      this.verticalScrollBar.scrollSize = this.content.height
+      this.verticalScrollBar.viewportSize = this.viewport.height
+      this.horizontalScrollBar.scrollSize = this.content.width
+      this.horizontalScrollBar.viewportSize = this.viewport.width
+
+      if (this._stickyScroll) {
+        const newMaxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height)
+        const newMaxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width)
+
+        if (this._stickyStart && !this._hasManualScroll) {
+          this.applyStickyStart(this._stickyStart)
+        } else {
+          if (this._stickyScrollTop) {
+            this.scrollTop = 0
+          } else if (this._stickyScrollBottom && newMaxScrollTop > 0) {
+            this.scrollTop = newMaxScrollTop
+          }
+
+          if (this._stickyScrollLeft) {
+            this.scrollLeft = 0
+          } else if (this._stickyScrollRight && newMaxScrollLeft > 0) {
+            this.scrollLeft = newMaxScrollLeft
+          }
+        }
+      }
+    } finally {
+      this._isApplyingStickyScroll = wasApplyingStickyScroll
+    }
+
+    // NOTE: This is obviously a workaround for something,
+    // which is that the bar props are recalculated when the viewport is resized,
+    // which intially happens onUpdate but is the viewport does not have the correct dimensions yet,
+    // then when it does, no update is triggered and when we do we are in the middle of a render,
+    // which just ignores the request. ¯\_(ツ)_/¯
+    // TODO: Fix this properly. How? Move yoga to native, get all changes for elements in one go
+    // and update all renderables in one go before rendering.
+    // OR: Move this logic to the viewport. IMHO the wrapper and viewport are overkill and not necessary.
+    //     The Scrollbox can be the viewport, we are using translations on the content anyway.
+    process.nextTick(() => {
+      this.requestRender()
+    })
+  }
+
+  // Setters for reactive properties
+  public set padding(value: number | `${number}%` | null | undefined) {
+    this.content.padding = value
+    this.requestRender()
+  }
+
+  public set paddingX(value: number | `${number}%` | null | undefined) {
+    this.content.paddingX = value
+    this.requestRender()
+  }
+
+  public set paddingY(value: number | `${number}%` | null | undefined) {
+    this.content.paddingY = value
+    this.requestRender()
+  }
+
+  public set paddingTop(value: number | `${number}%` | null | undefined) {
+    this.content.paddingTop = value
+    this.requestRender()
+  }
+
+  public set paddingRight(value: number | `${number}%` | null | undefined) {
+    this.content.paddingRight = value
+    this.requestRender()
+  }
+
+  public override set paddingBottom(value: number | `${number}%` | null | undefined) {
+    this.content.paddingBottom = value
+    this.requestRender()
+  }
+
+  public override set paddingLeft(value: number | `${number}%` | null | undefined) {
+    this.content.paddingLeft = value
+    this.requestRender()
+  }
+
+  public set rootOptions(options: ScrollBoxOptions["rootOptions"]) {
+    Object.assign(this, options)
+    this.requestRender()
+  }
+
+  public set wrapperOptions(options: ScrollBoxOptions["wrapperOptions"]) {
+    Object.assign(this.wrapper, options)
+    this.requestRender()
+  }
+
+  public set viewportOptions(options: ScrollBoxOptions["viewportOptions"]) {
+    Object.assign(this.viewport, options)
+    this.requestRender()
+  }
+
+  public set contentOptions(options: ScrollBoxOptions["contentOptions"]) {
+    Object.assign(this.content, options)
+    this.requestRender()
+  }
+
+  public set scrollbarOptions(options: ScrollBoxOptions["scrollbarOptions"]) {
+    Object.assign(this.verticalScrollBar, options)
+    Object.assign(this.horizontalScrollBar, options)
+    this.requestRender()
+  }
+
+  public set verticalScrollbarOptions(options: ScrollBoxOptions["verticalScrollbarOptions"]) {
+    Object.assign(this.verticalScrollBar, options)
+    this.requestRender()
+  }
+
+  public set horizontalScrollbarOptions(options: ScrollBoxOptions["horizontalScrollbarOptions"]) {
+    Object.assign(this.horizontalScrollBar, options)
+    this.requestRender()
+  }
+
+  public get scrollAcceleration(): ScrollAcceleration {
+    return this.scrollAccel
+  }
+
+  public set scrollAcceleration(value: ScrollAcceleration) {
+    this.scrollAccel = value
+  }
+
+  get viewportCulling(): boolean {
+    return this.content.viewportCulling
+  }
+
+  set viewportCulling(value: boolean) {
+    this.content.viewportCulling = value
+    this.requestRender()
+  }
+
+  protected override destroySelf(): void {
+    if (this.selectionListener) {
+      this._ctx.off("selection", this.selectionListener)
+      this.selectionListener = undefined
+    }
+    super.destroySelf()
+  }
+}