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/keybindings/KeybindingContext.tsx
+++ b/packages/@ant/ink/src/keybindings/KeybindingContext.tsx
@@ -1,84 +1,63 @@
-import React, {
-  createContext,
-  type RefObject,
-  useContext,
-  useLayoutEffect,
-  useMemo,
-} from 'react'
-import type { Key } from '../core/events/input-event.js'
-import {
-  type ChordResolveResult,
-  getBindingDisplayText,
-  resolveKeyWithChordState,
-} from './resolver.js'
-import type {
-  KeybindingContextName,
-  ParsedBinding,
-  ParsedKeystroke,
-} from './types.js'
+import React, { createContext, type RefObject, useContext, useLayoutEffect, useMemo } from 'react';
+import type { Key } from '../core/events/input-event.js';
+import { type ChordResolveResult, getBindingDisplayText, resolveKeyWithChordState } from './resolver.js';
+import type { KeybindingContextName, ParsedBinding, ParsedKeystroke } from './types.js';

 /** Handler registration for action callbacks */
 type HandlerRegistration = {
-  action: string
-  context: KeybindingContextName
-  handler: () => void
-}
+  action: string;
+  context: KeybindingContextName;
+  handler: () => void;
+};

 type KeybindingContextValue = {
  /** Resolve a key input to an action name (with chord support) */
-  resolve: (
-    input: string,
-    key: Key,
-    activeContexts: KeybindingContextName[],
-  ) => ChordResolveResult
+  resolve: (input: string, key: Key, activeContexts: KeybindingContextName[]) => ChordResolveResult;

  /** Update the pending chord state */
-  setPendingChord: (pending: ParsedKeystroke[] | null) => void
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;

  /** Get display text for an action (e.g., "ctrl+t") */
-  getDisplayText: (
-    action: string,
-    context: KeybindingContextName,
-  ) => string | undefined
+  getDisplayText: (action: string, context: KeybindingContextName) => string | undefined;

  /** All parsed bindings (for help display) */
-  bindings: ParsedBinding[]
+  bindings: ParsedBinding[];

  /** Current pending chord keystrokes (null if not in a chord) */
-  pendingChord: ParsedKeystroke[] | null
+  pendingChord: ParsedKeystroke[] | null;

  /** Currently active keybinding contexts (for priority resolution) */
-  activeContexts: Set<KeybindingContextName>
+  activeContexts: Set<KeybindingContextName>;

  /** Register a context as active (call on mount) */
-  registerActiveContext: (context: KeybindingContextName) => void
+  registerActiveContext: (context: KeybindingContextName) => void;

  /** Unregister a context (call on unmount) */
-  unregisterActiveContext: (context: KeybindingContextName) => void
+  unregisterActiveContext: (context: KeybindingContextName) => void;

  /** Register a handler for an action (used by useKeybinding) */
-  registerHandler: (registration: HandlerRegistration) => () => void
+  registerHandler: (registration: HandlerRegistration) => () => void;

  /** Invoke all handlers for an action (used by ChordInterceptor) */
-  invokeAction: (action: string) => boolean
-}
+  invokeAction: (action: string) => boolean;
+};

-const KeybindingContext = createContext<KeybindingContextValue | null>(null)
+const KeybindingContext = createContext<KeybindingContextValue | null>(null);

 type ProviderProps = {
-  bindings: ParsedBinding[]
+  bindings: ParsedBinding[];
  /** Ref for immediate access to pending chord (avoids React state delay) */
-  pendingChordRef: RefObject<ParsedKeystroke[] | null>
+  pendingChordRef: RefObject<ParsedKeystroke[] | null>;
  /** State value for re-renders (UI updates) */
-  pendingChord: ParsedKeystroke[] | null
-  setPendingChord: (pending: ParsedKeystroke[] | null) => void
-  activeContexts: Set<KeybindingContextName>
-  registerActiveContext: (context: KeybindingContextName) => void
-  unregisterActiveContext: (context: KeybindingContextName) => void
+  pendingChord: ParsedKeystroke[] | null;
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;
+  activeContexts: Set<KeybindingContextName>;
+  registerActiveContext: (context: KeybindingContextName) => void;
+  unregisterActiveContext: (context: KeybindingContextName) => void;
  /** Ref to handler registry (used by ChordInterceptor) */
-  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>
-  children: React.ReactNode
-}
+  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>;
+  children: React.ReactNode;
+};

 export function KeybindingProvider({
  bindings,
@@ -93,60 +72,54 @@ export function KeybindingProvider({
 }: ProviderProps): React.ReactNode {
  const value = useMemo<KeybindingContextValue>(() => {
    const getDisplay = (action: string, context: KeybindingContextName) =>
-      getBindingDisplayText(action, context, bindings)
+      getBindingDisplayText(action, context, bindings);

    // Register a handler for an action
    const registerHandler = (registration: HandlerRegistration) => {
-      const registry = handlerRegistryRef.current
-      if (!registry) return () => {}
+      const registry = handlerRegistryRef.current;
+      if (!registry) return () => {};

      if (!registry.has(registration.action)) {
-        registry.set(registration.action, new Set())
+        registry.set(registration.action, new Set());
      }
-      registry.get(registration.action)!.add(registration)
+      registry.get(registration.action)!.add(registration);

      // Return unregister function
      return () => {
-        const handlers = registry.get(registration.action)
+        const handlers = registry.get(registration.action);
        if (handlers) {
-          handlers.delete(registration)
+          handlers.delete(registration);
          if (handlers.size === 0) {
-            registry.delete(registration.action)
+            registry.delete(registration.action);
          }
        }
-      }
-    }
+      };
+    };

    // Invoke all handlers for an action
    const invokeAction = (action: string): boolean => {
-      const registry = handlerRegistryRef.current
-      if (!registry) return false
+      const registry = handlerRegistryRef.current;
+      if (!registry) return false;

-      const handlers = registry.get(action)
-      if (!handlers || handlers.size === 0) return false
+      const handlers = registry.get(action);
+      if (!handlers || handlers.size === 0) return false;

      // Find handlers whose context is active
      for (const registration of handlers) {
        if (activeContexts.has(registration.context)) {
-          registration.handler()
-          return true
+          registration.handler();
+          return true;
        }
      }
-      return false
-    }
+      return false;
+    };

    return {
      // Use ref for immediate access to pending chord, avoiding React state delay
      // This is critical for chord sequences where the second key might be pressed
      // before React re-renders with the updated pendingChord state
      resolve: (input, key, contexts) =>
-        resolveKeyWithChordState(
-          input,
-          key,
-          contexts,
-          bindings,
-          pendingChordRef.current,
-        ),
+        resolveKeyWithChordState(input, key, contexts, bindings, pendingChordRef.current),
      setPendingChord,
      getDisplayText: getDisplay,
      bindings,
@@ -156,7 +129,7 @@ export function KeybindingProvider({
      unregisterActiveContext,
      registerHandler,
      invokeAction,
-    }
+    };
  }, [
    bindings,
    pendingChordRef,
@@ -166,23 +139,17 @@ export function KeybindingProvider({
    registerActiveContext,
    unregisterActiveContext,
    handlerRegistryRef,
-  ])
+  ]);

-  return (
-    <KeybindingContext.Provider value={value}>
-      {children}
-    </KeybindingContext.Provider>
-  )
+  return <KeybindingContext.Provider value={value}>{children}</KeybindingContext.Provider>;
 }

 export function useKeybindingContext(): KeybindingContextValue {
-  const ctx = useContext(KeybindingContext)
+  const ctx = useContext(KeybindingContext);
  if (!ctx) {
-    throw new Error(
-      'useKeybindingContext must be used within KeybindingProvider',
-    )
+    throw new Error('useKeybindingContext must be used within KeybindingProvider');
  }
-  return ctx
+  return ctx;
 }

 /**
@@ -190,7 +157,7 @@ export function useKeybindingContext(): KeybindingContextValue {
 * Useful for components that may render before provider is available.
 */
 export function useOptionalKeybindingContext(): KeybindingContextValue | null {
-  return useContext(KeybindingContext)
+  return useContext(KeybindingContext);
 }

 /**
@@ -208,18 +175,15 @@ export function useOptionalKeybindingContext(): KeybindingContextValue | null {
 * }
 * ```
 */
-export function useRegisterKeybindingContext(
-  context: KeybindingContextName,
-  isActive: boolean = true,
-): void {
-  const keybindingContext = useOptionalKeybindingContext()
+export function useRegisterKeybindingContext(context: KeybindingContextName, isActive: boolean = true): void {
+  const keybindingContext = useOptionalKeybindingContext();

  useLayoutEffect(() => {
-    if (!keybindingContext || !isActive) return
+    if (!keybindingContext || !isActive) return;

-    keybindingContext.registerActiveContext(context)
+    keybindingContext.registerActiveContext(context);
    return () => {
-      keybindingContext.unregisterActiveContext(context)
-    }
-  }, [context, keybindingContext, isActive])
+      keybindingContext.unregisterActiveContext(context);
+    };
+  }, [context, keybindingContext, isActive]);
 }