@hexdspace/react 0.1.36 → 0.1.39

package/dist/index.d.ts

@@ -22,14 +22,14 @@ interface Notification {
     action?: NotificationAction;
 }
 
-interface NotificationListener {
-    notify: (notification: Notification) => void;
-}
-
 interface SendNotification {
     execute(channel: string, notification: Notification): Promise<void>;
 }
 
+interface NotificationListener {
+    notify: (notification: Notification) => void;
+}
+
 type UnsubscribeHandler = () => void;
 interface Subscribe {
     execute(channel: string, observer: NotificationListener): Promise<UnsubscribeHandler>;
@@ -547,6 +547,419 @@ declare class DialogController {
 }
 declare const dialogController: DialogController;
 
+type ScopeId = string;
+type RegionId = string;
+type ItemId = string;
+type Mode = 'move' | 'select';
+type CombineMode = 'union' | 'xor';
+type RegionKey = Readonly<{
+    scopeId: ScopeId;
+    regionId: RegionId;
+}>;
+type CursorFallback = {
+    kind: 'none';
+} | {
+    kind: 'first';
+} | {
+    kind: 'last';
+} | {
+    kind: 'nth';
+    idx: number;
+} | {
+    kind: 'id';
+    id: ItemId;
+} | {
+    kind: 'nearestTo';
+    id: ItemId;
+} | {
+    kind: 'sameIndex';
+};
+
+interface RegionSelection {
+    cursor: ItemId | null;
+    toggled: Set<ItemId>;
+    selectAnchor: ItemId | null;
+}
+
+interface ScopeState {
+    activeRegion: RegionId | null;
+    mode: Mode;
+    regions: Record<RegionId, RegionSelection>;
+}
+
+interface SelectionState {
+    scopeStack: ScopeId[];
+    scopes: Record<ScopeId, ScopeState>;
+    items: Record<string, ItemId[]>;
+}
+
+type ClearTarget = {
+    kind: 'activeScope';
+} | {
+    kind: 'scope';
+    scopeId: ScopeId;
+} | {
+    kind: 'activeRegion';
+} | {
+    kind: 'region';
+    key: RegionKey;
+};
+interface ClearSelectionArgs {
+    clearToggles?: boolean;
+    exitSelectMode?: boolean;
+    clearAnchor?: boolean;
+}
+interface RegisterRegionArgs {
+    key: RegionKey;
+    getRegionItems: () => ItemId[];
+    makeActive?: boolean;
+    initialCursor?: ItemId;
+}
+interface HandleSelection {
+    pushScope(scopeId: ScopeId): void;
+    popScope(): ScopeId | null;
+    setActiveScope(scopeId: ScopeId): void;
+    ensureScope(scopeId: ScopeId): void;
+    registerRegion(args: RegisterRegionArgs): (fallback?: CursorFallback) => void;
+    unregisterRegion(key: RegionKey): void;
+    setActiveRegion(key: RegionKey): void;
+    setCursor(key: RegionKey, itemId: ItemId | null): void;
+    moveCursor(key: RegionKey, delta: number): void;
+    enterSelectMode(key: RegionKey): void;
+    exitSelectMode(scopeId: ScopeId): void;
+    toggleItem(key: RegionKey, itemId?: ItemId | null): void;
+    clearSelection(target: ClearTarget, args?: ClearSelectionArgs): void;
+}
+
+interface QuerySelection {
+    getActiveScope(): ScopeId | null;
+    getActiveRegion(scopeId: ScopeId): RegionKey | null;
+    getMode(scopeId: ScopeId): Mode;
+    getCursor(key: RegionKey): ItemId | null;
+    isSelected(key: RegionKey, itemId: ItemId): boolean;
+    getSelectedIds(key: RegionKey): readonly ItemId[];
+    getToggledIds(key: RegionKey): readonly ItemId[];
+    getRangeIds(key: RegionKey): readonly ItemId[];
+}
+
+interface SelectionStore {
+    get(): SelectionState;
+    set(next: SelectionState): void;
+}
+
+declare class SelectionController {
+    private readonly handleSelection;
+    private readonly querySelection;
+    private readonly selectionStore;
+    private readonly subscribeFn;
+    private version;
+    constructor(deps: SelectionControllerDeps);
+    registerRegion(args: RegisterRegionArgs): (fallback?: CursorFallback) => void;
+    pushScope(scopeId: ScopeId): void;
+    popScope(): ScopeId | null;
+    setActiveScope(scopeId: ScopeId): void;
+    ensureScope(scopeId: ScopeId): void;
+    unregisterRegion(key: RegionKey): void;
+    setActiveRegion(key: RegionKey): void;
+    setCursor(key: RegionKey, itemId: ItemId | null): void;
+    moveCursor(key: RegionKey, delta: number): void;
+    enterSelectMode(key: RegionKey): void;
+    exitSelectMode(scopeId: ScopeId): void;
+    toggleItem(key: RegionKey, itemId?: ItemId | null): void;
+    clearSelection(target: ClearTarget, args?: ClearSelectionArgs): void;
+    getActiveScope(): ScopeId | null;
+    getActiveRegion(scopeId: ScopeId): RegionKey | null;
+    getActiveItem(key?: RegionKey): ItemId | null;
+    getItems(key?: RegionKey): readonly ItemId[];
+    getSelectedIds(key?: RegionKey): readonly ItemId[];
+    getToggledIds(key?: RegionKey): readonly ItemId[];
+    getRangeIds(key?: RegionKey): readonly ItemId[];
+    isSelected(key: RegionKey, itemId: ItemId): boolean;
+    getMode(scopeId: ScopeId): Mode;
+    getQuery(): QuerySelection;
+    getStore(): SelectionStore;
+    getHandle(): HandleSelection;
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+    private resolveKey;
+}
+type SelectionControllerDeps = {
+    handleSelection: HandleSelection;
+    querySelection: QuerySelection;
+    selectionStore: SelectionStore;
+};
+declare const createSelectionController: (overrides?: Partial<SelectionControllerDeps>) => SelectionController;
+
+declare class InMemorySelectionStore implements SelectionStore {
+    private state;
+    constructor(state?: SelectionState);
+    get(): SelectionState;
+    set(next: SelectionState): void;
+}
+
+type SelectionControllerProviderProps = {
+    readonly children: React__default.ReactNode;
+    readonly controller: SelectionController;
+};
+declare function SelectionControllerProvider({ children, controller }: SelectionControllerProviderProps): react_jsx_runtime.JSX.Element;
+declare function useSelectionController(): SelectionController;
+
+type ShortcutHandler = (e: KeyboardEvent) => void;
+
+interface ShortcutBinding {
+    combos: string[];
+    handler: ShortcutHandler;
+    description: string;
+    group?: string;
+}
+
+interface ShortcutRegistration {
+    id: string;
+    scopeId: string;
+    bindings: ShortcutBinding[];
+    ignoreTyping?: boolean;
+    preventDefault?: boolean;
+}
+
+interface ShortcutScope {
+    id: string;
+    enabled: boolean;
+    priority: number;
+    exclusive?: boolean;
+    refCount: number;
+}
+
+declare class ScopeManager {
+    private scopes;
+    define(id: string, priority: number, exclusive?: boolean): void;
+    enable(id: string): void;
+    disable(id: string): void;
+    isAnyExclusiveActiveAbove(priority: number): boolean;
+    isScopeActive(id: string): boolean;
+    getState(id: string): ShortcutScope | null;
+}
+
+interface EnableScope {
+    enableScope(id: string): void;
+}
+
+interface DisableScope {
+    disableScope(id: string): void;
+}
+
+interface ListedShortcut {
+    registrationId: string;
+    scopeId: string;
+    combos: string[];
+    description: string;
+    group?: string;
+}
+type GroupedShortcuts = Record<string, ListedShortcut[]>;
+
+interface ListShortcuts {
+    listShortcutsByScope(): GroupedShortcuts;
+}
+
+interface RegisterShortcut {
+    registerShortcut(reg: Omit<ShortcutRegistration, 'id'>): string;
+}
+
+interface UnregisterShortcut {
+    unregisterShortcut(id: string): void;
+}
+
+declare class EnableScopeUseCase implements EnableScope {
+    private readonly scopes;
+    constructor(scopes: ScopeManager);
+    enableScope(id: string): void;
+}
+
+declare class DisableScopeUseCase implements DisableScope {
+    private readonly scopes;
+    constructor(scopes: ScopeManager);
+    disableScope(id: string): void;
+}
+
+interface ShortcutRegistry {
+    addMany(items: ListedShortcut[]): void;
+    removeByRegistration(registrationId: string): void;
+    snapshotGroupedByScope(): GroupedShortcuts;
+}
+
+declare class ListShortcutsUseCase implements ListShortcuts {
+    private readonly registry;
+    constructor(registry: ShortcutRegistry);
+    listShortcutsByScope(): GroupedShortcuts;
+}
+
+interface HotkeyEngineHandle {
+    dispose(): void;
+}
+interface HotkeyEngine {
+    register(bindings: ShortcutBinding[], opts: {
+        guard?: (e: KeyboardEvent) => boolean;
+        preventDefault?: boolean;
+        target?: Window | HTMLElement;
+    }): HotkeyEngineHandle;
+}
+
+declare class RegisterShortcutUseCase implements RegisterShortcut {
+    private readonly engine;
+    private readonly scopes;
+    private readonly registry;
+    private store;
+    constructor(engine: HotkeyEngine, scopes: ScopeManager, registry: ShortcutRegistry);
+    registerShortcut(regInput: Omit<ShortcutRegistration, 'id'>): string;
+    unregister(id: string): void;
+}
+
+declare class UnregisterShortcutUseCase implements UnregisterShortcut {
+    private readonly registry;
+    constructor(registry: RegisterShortcutUseCase);
+    unregisterShortcut(id: string): void;
+}
+
+declare class KeyboardController {
+    private readonly scopes;
+    private readonly register;
+    private readonly unregister;
+    private readonly enableScope;
+    private readonly disableScope;
+    private readonly listShortcuts;
+    constructor(scopes: ScopeManager, register: RegisterShortcut, unregister: UnregisterShortcut, enableScope: EnableScope, disableScope: DisableScope, listShortcuts: ListShortcutsUseCase, config?: {
+        predefinedScopes?: Array<{
+            id: string;
+            priority: number;
+            exclusive?: boolean;
+            enabled?: boolean;
+        }>;
+    });
+    handleDefineScope(id: string, priority: number, exclusive?: boolean): void;
+    handleEnableScope(id: string): void;
+    handleDisableScope(id: string): void;
+    handleRegisterShortcut(params: Omit<ShortcutRegistration, 'id'>): string;
+    handleUnregisterShortcut(id: string): void;
+    handleListShortcutsByScope(): GroupedShortcuts;
+}
+
+declare const KeyboardProvider: React__default.FC<{
+    children: React__default.ReactNode;
+}>;
+declare function useKeyboardController(): KeyboardController;
+
+declare function useShortcut(scopeId: string, bindings: ShortcutBinding[], opts?: {
+    ignoreTyping?: boolean;
+    preventDefault?: boolean;
+}): void;
+
+declare function useShortcutScope(scopeId: string, enabled?: boolean): void;
+
+type VimDirection = 'up' | 'down' | 'left' | 'right';
+type VimInterDirection = 'left' | 'right';
+type VimPending = null | 'g';
+interface VimKeyState {
+    count: string;
+    pending: VimPending;
+}
+
+interface VimRegionMeta {
+    key: RegionKey;
+    orderIndex: number;
+    intra: ReadonlySet<VimDirection>;
+    inter: ReadonlySet<VimInterDirection>;
+    focusContainer?: () => void;
+    scrollToCursor?: () => void;
+    focusOnCursorChange?: boolean;
+    enterCursorFallback?: CursorFallback;
+}
+
+declare class VimRegionRegistry {
+    private readonly byScope;
+    register(meta: VimRegionMeta): void;
+    unregister(key: RegionKey): void;
+    get(key: RegionKey): VimRegionMeta | null;
+    list(scopeId: ScopeId): VimRegionMeta[];
+    neighbor(scopeId: ScopeId, current: RegionKey, dir: VimInterDirection, count: number): RegionKey | null;
+}
+
+declare class VimHandleKeyUseCase {
+    private readonly selection;
+    private readonly query;
+    private readonly getItems;
+    private readonly regions;
+    private readonly stateByScope;
+    constructor(selection: HandleSelection, query: QuerySelection, getItems: (key: RegionKey) => readonly ItemId[], regions: VimRegionRegistry);
+    reset(scopeId?: ScopeId): void;
+    handleChar(char: string, e: KeyboardEvent): void;
+    handleEscape(e: KeyboardEvent): void;
+    private applyDirectional;
+    private goToLast;
+    private goToIndex;
+    private afterRegionChange;
+    private afterCursorChange;
+    private applyFallbackCursor;
+    private getCursorIndex;
+    private resolveInterRegionFallback;
+}
+
+declare class VimController {
+    private readonly regions;
+    private readonly handleKey;
+    private readonly selection;
+    constructor(selection: SelectionController, regions?: VimRegionRegistry, handleKey?: VimHandleKeyUseCase);
+    handleRegisterRegionMeta(meta: VimRegionMeta): void;
+    handleUnregisterRegionMeta(key: RegionKey): void;
+    handleCharKey(char: string, e: KeyboardEvent): void;
+    handleEscape(e: KeyboardEvent): void;
+    resetActiveScope(): void;
+    getSelection(): SelectionController;
+}
+type VimControllerDeps = {
+    selection: SelectionController;
+    regions: VimRegionRegistry;
+    handleKey: VimHandleKeyUseCase;
+};
+declare const createVimController: (overrides?: Partial<VimControllerDeps>) => VimController;
+
+type VimControllerProviderProps = {
+    readonly children: React__default.ReactNode;
+    readonly controller: VimController;
+};
+declare function VimControllerProvider({ children, controller }: VimControllerProviderProps): react_jsx_runtime.JSX.Element;
+declare function useVimController(): VimController;
+
+type VimBindingOptions = {
+    enabled?: boolean;
+};
+declare function useVimBindings(keyboardScopeId: string, options?: VimBindingOptions): void;
+
+type UseVimRegionArgs = {
+    key: RegionKey;
+    orderIndex: number;
+    getRegionItems: () => ItemId[];
+    makeActive?: boolean;
+    initialCursor?: ItemId;
+    intra?: readonly VimDirection[];
+    inter?: readonly VimInterDirection[];
+    enterCursorFallback?: CursorFallback;
+    itemDataAttr?: string;
+    focusOnCursorChange?: boolean;
+    keyboardScopeId?: string;
+    bindKeys?: boolean;
+    refreshDeps?: React__default.DependencyList;
+};
+type UseVimRegionResult = {
+    getItemProps: (itemId: ItemId) => React__default.HTMLAttributes<HTMLElement>;
+    refresh: (fallback?: CursorFallback) => void;
+    activeId: ItemId | null;
+    selectedIds: readonly ItemId[];
+    rangeIds: readonly ItemId[];
+    toggledIds: readonly ItemId[];
+    mode: 'move' | 'select';
+    isSelected: (itemId: ItemId) => boolean;
+};
+declare function useVimRegion(containerRef: React__default.RefObject<HTMLElement | null>, args: UseVimRegionArgs): UseVimRegionResult;
+
 declare const dialogSurfaceVariants: (props?: ({
     chrome?: "flat" | "glass" | "glow" | "hairline" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
@@ -687,6 +1100,7 @@ interface DropdownMenuProps extends VariantProps<typeof dropdownMenuContentVaria
     children: React.ReactNode;
     open?: boolean;
     defaultOpen?: boolean;
+    keepMounted?: boolean;
     onOpenChange?: (open: boolean) => void;
     hoverOpen?: boolean;
     hoverCloseDelayMs?: number;
@@ -703,7 +1117,7 @@ interface DropdownMenuProps extends VariantProps<typeof dropdownMenuContentVaria
     style?: React.CSSProperties;
     contentProps?: DropdownMenuContentProps;
 }
-declare function DropdownMenu({ trigger, children, open, defaultOpen, onOpenChange, hoverOpen, hoverCloseDelayMs, modal, side, align, sideOffset, alignOffset, collisionPadding, portalContainer, ariaLabel, ariaLabelledBy, chrome, orientation, className, style, contentProps, }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
+declare function DropdownMenu({ trigger, children, open, defaultOpen, keepMounted, onOpenChange, hoverOpen, hoverCloseDelayMs, modal, side, align, sideOffset, alignOffset, collisionPadding, portalContainer, ariaLabel, ariaLabelledBy, chrome, orientation, className, style, contentProps, }: DropdownMenuProps): react_jsx_runtime.JSX.Element;
 interface DropdownMenuItemProps extends React.ComponentPropsWithoutRef<typeof DropdownMenu$1.Item>, Omit<VariantProps<typeof dropdownMenuItemVariants>, 'orientation'> {
 }
 declare const DropdownMenuItem: React.ForwardRefExoticComponent<DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>>;
@@ -716,4 +1130,4 @@ interface KbdProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<t
 }
 declare const Kbd: React.ForwardRefExoticComponent<KbdProps & React.RefAttributes<HTMLSpanElement>>;
 
-export { AuthController, AuthControllerCtx, type AuthControllerDeps, AuthControllerProvider, AuthDispatchCtx, AuthProvider, type AuthState, AuthStateCtx, Button, type ButtonProps, type CacheInstruction, ConfirmDialog, type ConfirmDialogProps, type ConfirmPayload, CustomDialog, type CustomDialogPayload, type CustomDialogProps, type CustomInstruction, DEFAULT_NOTIFICATION_CHANNEL, type DefaultDialogPayloads, type DefaultDialogTemplateKey, DefaultDialogTemplateKeys, Dialog, DialogContent, DialogController, DialogHost, type DialogInstance, type DialogOptions, type DialogProps, type DialogTemplate, DropdownMenu, DropdownMenuItem, type DropdownMenuItemProps, type DropdownMenuProps, DropdownMenuSeparator, type ErrorResponse, Field, type FieldProps, type GenericResponse, type HttpClient, HttpError, type HttpMethod, type HttpResponse, InfoDialog, type InfoDialogProps, type InfoPayload, Input, type InputProps, type Instruction, type InstructionContext, Kbd, type KbdProps, MockAuthHttpClient, MockHttpClient, type MutationFn, type Notification, type NotificationAction, NotificationHost, type NotificationInstruction, type NotificationVariant, NotifierController, type OnSuccessFn, type OptimisticSnapshot, type OptimisticUpdateFn, Popover, type PopoverProps, RedirectIfAuthed, type RedirectIfAuthedProps, type RequestConfig, RequireAuth, type RequireAuthProps, type ResolvedToastTheme, type ResponsiveMutation, Skeleton, type SkeletonProps, Textarea, type TextareaProps, type ToastActionTheme, type ToastTheme, type ToastTransition, type ToastifyCSSVars, Tooltip, type UIFail, type UIOk, type UIResult, type User, authController, controllerFactory, createAuthController, dialogController, httpClient as fetchHttpClient, getDialogTemplate, notifierController, registerDefaultDialogs, registerDialogTemplate, resolveToastTheme, ui, unregisterDialogTemplate, useAuth, useAuthActions, useAuthController, useAuthDispatch, useAuthedUser, useDialog, useResponsiveMutation };
+export { AuthController, AuthControllerCtx, type AuthControllerDeps, AuthControllerProvider, AuthDispatchCtx, AuthProvider, type AuthState, AuthStateCtx, Button, type ButtonProps, type CacheInstruction, type ClearSelectionArgs, type ClearTarget, type CombineMode, ConfirmDialog, type ConfirmDialogProps, type ConfirmPayload, type CursorFallback, CustomDialog, type CustomDialogPayload, type CustomDialogProps, type CustomInstruction, DEFAULT_NOTIFICATION_CHANNEL, type DefaultDialogPayloads, type DefaultDialogTemplateKey, DefaultDialogTemplateKeys, Dialog, DialogContent, DialogController, DialogHost, type DialogInstance, type DialogOptions, type DialogProps, type DialogTemplate, type DisableScope, DisableScopeUseCase, DropdownMenu, DropdownMenuItem, type DropdownMenuItemProps, type DropdownMenuProps, DropdownMenuSeparator, type EnableScope, EnableScopeUseCase, type ErrorResponse, Field, type FieldProps, type GenericResponse, type HandleSelection, type HttpClient, HttpError, type HttpMethod, type HttpResponse, InMemorySelectionStore, InfoDialog, type InfoDialogProps, type InfoPayload, Input, type InputProps, type Instruction, type InstructionContext, type ItemId, Kbd, type KbdProps, KeyboardProvider, type ListShortcuts, ListShortcutsUseCase, MockAuthHttpClient, MockHttpClient, type Mode, type MutationFn, type Notification, type NotificationAction, NotificationHost, type NotificationInstruction, type NotificationVariant, NotifierController, type OnSuccessFn, type OptimisticSnapshot, type OptimisticUpdateFn, Popover, type PopoverProps, type QuerySelection, RedirectIfAuthed, type RedirectIfAuthedProps, type RegionId, type RegionKey, type RegionSelection, type RegisterRegionArgs, type RegisterShortcut, RegisterShortcutUseCase, type RequestConfig, RequireAuth, type RequireAuthProps, type ResolvedToastTheme, type ResponsiveMutation, type ScopeId, ScopeManager, type ScopeState, SelectionController, type SelectionControllerDeps, SelectionControllerProvider, type SelectionState, type SelectionStore, type ShortcutBinding, type ShortcutHandler, type ShortcutRegistration, type ShortcutScope, Skeleton, type SkeletonProps, Textarea, type TextareaProps, type ToastActionTheme, type ToastTheme, type ToastTransition, type ToastifyCSSVars, Tooltip, type UIFail, type UIOk, type UIResult, type UnregisterShortcut, UnregisterShortcutUseCase, type UseVimRegionArgs, type UseVimRegionResult, type User, VimController, type VimControllerDeps, VimControllerProvider, type VimDirection, type VimInterDirection, type VimKeyState, type VimPending, type VimRegionMeta, VimRegionRegistry, authController, controllerFactory, createAuthController, createSelectionController, createVimController, dialogController, httpClient as fetchHttpClient, getDialogTemplate, notifierController, registerDefaultDialogs, registerDialogTemplate, resolveToastTheme, ui, unregisterDialogTemplate, useAuth, useAuthActions, useAuthController, useAuthDispatch, useAuthedUser, useDialog, useKeyboardController, useResponsiveMutation, useSelectionController, useShortcut, useShortcutScope, useVimBindings, useVimController, useVimRegion };