style: 格式化 packages/@ant/ 下所有文件以通过 biome ci

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-06-23 00:35:51 +00:00 · 2026-05-01 21:55:51 +08:00
parent c32f26cf21
commit 9ea9859dce
92 changed files with 5903 additions and 5188 deletions
--- a/packages/@ant/ink/src/components/ScrollBox.tsx
+++ b/packages/@ant/ink/src/components/ScrollBox.tsx
@@ -1,20 +1,14 @@
-import React, {
-  type PropsWithChildren,
-  type Ref,
-  useImperativeHandle,
-  useRef,
-  useState,
-} from 'react'
-import type { Except } from 'type-fest'
-import type { DOMElement } from '../core/dom.js'
-import { markDirty, scheduleRenderFrom } from '../core/dom.js'
-import { markCommitStart } from '../core/reconciler.js'
-import type { Styles } from '../core/styles.js'
-import Box from './Box.js'
+import React, { type PropsWithChildren, type Ref, useImperativeHandle, useRef, useState } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../core/dom.js';
+import { markDirty, scheduleRenderFrom } from '../core/dom.js';
+import { markCommitStart } from '../core/reconciler.js';
+import type { Styles } from '../core/styles.js';
+import Box from './Box.js';

 export type ScrollBoxHandle = {
-  scrollTo: (y: number) => void
-  scrollBy: (dy: number) => void
+  scrollTo: (y: number) => void;
+  scrollBy: (dy: number) => void;
  /**
   * Scroll so `el`'s top is at the viewport top (plus `offset`). Unlike
   * scrollTo which bakes a number that's stale by the time the throttled
@@ -22,24 +16,24 @@ export type ScrollBoxHandle = {
   * render-node-to-output reads `el.yogaNode.getComputedTop()` in the
   * SAME Yoga pass that computes scrollHeight. Deterministic. One-shot.
   */
-  scrollToElement: (el: DOMElement, offset?: number) => void
-  scrollToBottom: () => void
-  getScrollTop: () => number
-  getPendingDelta: () => number
-  getScrollHeight: () => number
+  scrollToElement: (el: DOMElement, offset?: number) => void;
+  scrollToBottom: () => void;
+  getScrollTop: () => number;
+  getPendingDelta: () => number;
+  getScrollHeight: () => number;
  /**
   * Like getScrollHeight, but reads Yoga directly instead of the cached
   * value written by render-node-to-output (throttled, up to 16ms stale).
   * Use when you need a fresh value in useLayoutEffect after a React commit
   * that grew content. Slightly more expensive (native Yoga call).
   */
-  getFreshScrollHeight: () => number
-  getViewportHeight: () => number
+  getFreshScrollHeight: () => number;
+  getViewportHeight: () => number;
  /**
   * Absolute screen-buffer row of the first visible content line (inside
   * padding). Used for drag-to-scroll edge detection.
   */
-  getViewportTop: () => number
+  getViewportTop: () => number;
  /**
   * True when scroll is pinned to the bottom. Set by scrollToBottom, the
   * initial stickyScroll attribute, and by the renderer when positional
@@ -47,14 +41,14 @@ export type ScrollBoxHandle = {
   * scrollTo/scrollBy. Stable signal for "at bottom" that doesn't depend on
   * layout values (unlike scrollTop+viewportH >= scrollHeight).
   */
-  isSticky: () => boolean
+  isSticky: () => boolean;
  /**
   * Subscribe to imperative scroll changes (scrollTo/scrollBy/scrollToBottom).
   * Does NOT fire for stickyScroll updates done by the Ink renderer — those
   * happen during Ink's render phase after React has committed. Callers that
   * care about the sticky case should treat "at bottom" as a fallback.
   */
-  subscribe: (listener: () => void) => () => void
+  subscribe: (listener: () => void) => () => void;
  /**
   * Set the render-time scrollTop clamp to the currently-mounted children's
   * coverage span. Called by useVirtualScroll after computing its range;
@@ -63,20 +57,17 @@ export type ScrollBoxHandle = {
   * content instead of blank spacer. Pass undefined to disable (sticky,
   * cold start).
   */
-  setClampBounds: (min: number | undefined, max: number | undefined) => void
-}
+  setClampBounds: (min: number | undefined, max: number | undefined) => void;
+};

-export type ScrollBoxProps = Except<
-  Styles,
-  'textWrap' | 'overflow' | 'overflowX' | 'overflowY'
-> & {
-  ref?: Ref<ScrollBoxHandle>
+export type ScrollBoxProps = Except<Styles, 'textWrap' | 'overflow' | 'overflowX' | 'overflowY'> & {
+  ref?: Ref<ScrollBoxHandle>;
  /**
   * When true, automatically pins scroll position to the bottom when content
   * grows. Unset manually via scrollTo/scrollBy to break the stickiness.
   */
-  stickyScroll?: boolean
-}
+  stickyScroll?: boolean;
+};

 /**
 * A Box with `overflow: scroll` and an imperative scroll API.
@@ -88,13 +79,8 @@ export type ScrollBoxProps = Except<
 *
 * Works best inside a fullscreen (constrained-height root) Ink tree.
 */
-function ScrollBox({
-  children,
-  ref,
-  stickyScroll,
-  ...style
-}: PropsWithChildren<ScrollBoxProps>): React.ReactNode {
-  const domRef = useRef<DOMElement>(null)
+function ScrollBox({ children, ref, stickyScroll, ...style }: PropsWithChildren<ScrollBoxProps>): React.ReactNode {
+  const domRef = useRef<DOMElement>(null);
  // scrollTo/scrollBy bypass React: they mutate scrollTop on the DOM node,
  // mark it dirty, and call the root's throttled scheduleRender directly.
  // The Ink renderer reads scrollTop from the node — no React state needed,
@@ -103,113 +89,109 @@ function ScrollBox({
  // render — otherwise scheduleRender's leading edge fires on the FIRST
  // event before subsequent events mutate scrollTop. scrollToBottom still
  // forces a React render: sticky is attribute-observed, no DOM-only path.
-  const [, forceRender] = useState(0)
-  const listenersRef = useRef(new Set<() => void>())
-  const renderQueuedRef = useRef(false)
+  const [, forceRender] = useState(0);
+  const listenersRef = useRef(new Set<() => void>());
+  const renderQueuedRef = useRef(false);

  const notify = () => {
-    for (const l of listenersRef.current) l()
-  }
+    for (const l of listenersRef.current) l();
+  };

  function scrollMutated(el: DOMElement): void {
    // Signal background intervals (IDE poll, LSP poll, GCS fetch, orphan
    // check) to skip their next tick — they compete for the event loop and
    // contributed to 1402ms max frame gaps during scroll drain.
    // noop — injected by business layer via onScrollActivity callback
-    markDirty(el)
-    markCommitStart()
-    notify()
-    if (renderQueuedRef.current) return
-    renderQueuedRef.current = true
+    markDirty(el);
+    markCommitStart();
+    notify();
+    if (renderQueuedRef.current) return;
+    renderQueuedRef.current = true;
    queueMicrotask(() => {
-      renderQueuedRef.current = false
-      scheduleRenderFrom(el)
-    })
+      renderQueuedRef.current = false;
+      scheduleRenderFrom(el);
+    });
  }

  useImperativeHandle(
    ref,
    (): ScrollBoxHandle => ({
      scrollTo(y: number) {
-        const el = domRef.current
-        if (!el) return
+        const el = domRef.current;
+        if (!el) return;
        // Explicit false overrides the DOM attribute so manual scroll
        // breaks stickiness. Render code checks ?? precedence.
-        el.stickyScroll = false
-        el.pendingScrollDelta = undefined
-        el.scrollAnchor = undefined
-        el.scrollTop = Math.max(0, Math.floor(y))
-        scrollMutated(el)
+        el.stickyScroll = false;
+        el.pendingScrollDelta = undefined;
+        el.scrollAnchor = undefined;
+        el.scrollTop = Math.max(0, Math.floor(y));
+        scrollMutated(el);
      },
      scrollToElement(el: DOMElement, offset = 0) {
-        const box = domRef.current
-        if (!box) return
-        box.stickyScroll = false
-        box.pendingScrollDelta = undefined
-        box.scrollAnchor = { el, offset }
-        scrollMutated(box)
+        const box = domRef.current;
+        if (!box) return;
+        box.stickyScroll = false;
+        box.pendingScrollDelta = undefined;
+        box.scrollAnchor = { el, offset };
+        scrollMutated(box);
      },
      scrollBy(dy: number) {
-        const el = domRef.current
-        if (!el) return
-        el.stickyScroll = false
+        const el = domRef.current;
+        if (!el) return;
+        el.stickyScroll = false;
        // Wheel input cancels any in-flight anchor seek — user override.
-        el.scrollAnchor = undefined
+        el.scrollAnchor = undefined;
        // Accumulate in pendingScrollDelta; renderer drains it at a capped
        // rate so fast flicks show intermediate frames. Pure accumulator:
        // scroll-up followed by scroll-down naturally cancels.
-        el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy)
-        scrollMutated(el)
+        el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+        scrollMutated(el);
      },
      scrollToBottom() {
-        const el = domRef.current
-        if (!el) return
-        el.pendingScrollDelta = undefined
-        el.stickyScroll = true
-        markDirty(el)
-        notify()
-        forceRender(n => n + 1)
+        const el = domRef.current;
+        if (!el) return;
+        el.pendingScrollDelta = undefined;
+        el.stickyScroll = true;
+        markDirty(el);
+        notify();
+        forceRender(n => n + 1);
      },
      getScrollTop() {
-        return domRef.current?.scrollTop ?? 0
+        return domRef.current?.scrollTop ?? 0;
      },
      getPendingDelta() {
        // Accumulated-but-not-yet-drained delta. useVirtualScroll needs
        // this to mount the union [committed, committed+pending] range —
        // otherwise intermediate drain frames find no children (blank).
-        return domRef.current?.pendingScrollDelta ?? 0
+        return domRef.current?.pendingScrollDelta ?? 0;
      },
      getScrollHeight() {
-        return domRef.current?.scrollHeight ?? 0
+        return domRef.current?.scrollHeight ?? 0;
      },
      getFreshScrollHeight() {
-        const content = domRef.current?.childNodes[0] as DOMElement | undefined
-        return (
-          content?.yogaNode?.getComputedHeight() ??
-          domRef.current?.scrollHeight ??
-          0
-        )
+        const content = domRef.current?.childNodes[0] as DOMElement | undefined;
+        return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
      },
      getViewportHeight() {
-        return domRef.current?.scrollViewportHeight ?? 0
+        return domRef.current?.scrollViewportHeight ?? 0;
      },
      getViewportTop() {
-        return domRef.current?.scrollViewportTop ?? 0
+        return domRef.current?.scrollViewportTop ?? 0;
      },
      isSticky() {
-        const el = domRef.current
-        if (!el) return false
-        return el.stickyScroll ?? Boolean(el.attributes['stickyScroll'])
+        const el = domRef.current;
+        if (!el) return false;
+        return el.stickyScroll ?? Boolean(el.attributes['stickyScroll']);
      },
      subscribe(listener: () => void) {
-        listenersRef.current.add(listener)
-        return () => listenersRef.current.delete(listener)
+        listenersRef.current.add(listener);
+        return () => listenersRef.current.delete(listener);
      },
      setClampBounds(min, max) {
-        const el = domRef.current
-        if (!el) return
-        el.scrollClampMin = min
-        el.scrollClampMax = max
+        const el = domRef.current;
+        if (!el) return;
+        el.scrollClampMin = min;
+        el.scrollClampMax = max;
      },
    }),
    // notify/scrollMutated are inline (no useCallback) but only close over
@@ -217,7 +199,7 @@ function ScrollBox({
    // every render (which re-registers the ref = churn).
    // eslint-disable-next-line react-hooks/exhaustive-deps
    [],
-  )
+  );

  // Structure: outer viewport (overflow:scroll, constrained height) >
  // inner content (flexGrow:1, flexShrink:0 — fills at least the viewport
@@ -233,8 +215,8 @@ function ScrollBox({
  return (
    <ink-box
      ref={el => {
-        domRef.current = el
-        if (el) el.scrollTop ??= 0
+        domRef.current = el;
+        if (el) el.scrollTop ??= 0;
      }}
      style={{
        flexWrap: 'nowrap',
@@ -251,7 +233,7 @@ function ScrollBox({
        {children}
      </Box>
    </ink-box>
-  )
+  );
 }

-export default ScrollBox
+export default ScrollBox;