@jiaozhiye/qm-design-react 1.11.1 → 1.11.2

package/lib/virtual-list/index.d.ts

@@ -0,0 +1,3 @@
+import VirtualList from './src/virtual-list';
+export type { VirtualListProps } from './src/virtual-list';
+export default VirtualList;

package/lib/virtual-list/src/core.d.ts

@@ -0,0 +1,133 @@
+export * from './utils';
+type ScrollDirection = 'forward' | 'backward';
+type ScrollAlignment = 'start' | 'center' | 'end' | 'auto';
+type ScrollBehavior = 'auto' | 'smooth';
+export interface ScrollToOptions {
+    align?: ScrollAlignment;
+    behavior?: ScrollBehavior;
+}
+type ScrollToOffsetOptions = ScrollToOptions;
+type ScrollToIndexOptions = ScrollToOptions;
+export interface Range {
+    startIndex: number;
+    endIndex: number;
+    overscan: number;
+    count: number;
+}
+type Key = number | string | bigint;
+export interface VirtualItem {
+    key: Key;
+    index: number;
+    start: number;
+    end: number;
+    size: number;
+    lane: number;
+}
+export interface Rect {
+    width: number;
+    height: number;
+}
+export declare const defaultKeyExtractor: (index: number) => number;
+export declare const defaultRangeExtractor: (range: Range) => number[];
+export declare const observeElementRect: <T extends Element>(instance: Virtualizer<T, any>, cb: (rect: Rect) => void) => (() => void) | undefined;
+export declare const observeWindowRect: (instance: Virtualizer<Window, any>, cb: (rect: Rect) => void) => (() => void) | undefined;
+type ObserveOffsetCallBack = (offset: number, isScrolling: boolean) => void;
+export declare const observeElementOffset: <T extends Element>(instance: Virtualizer<T, any>, cb: ObserveOffsetCallBack) => (() => void) | undefined;
+export declare const observeWindowOffset: (instance: Virtualizer<Window, any>, cb: ObserveOffsetCallBack) => (() => void) | undefined;
+export declare const measureElement: <TItemElement extends Element>(element: TItemElement, entry: ResizeObserverEntry | undefined, instance: Virtualizer<any, TItemElement>) => number;
+export declare const windowScroll: <T extends Window>(offset: number, { adjustments, behavior }: {
+    adjustments?: number | undefined;
+    behavior?: ScrollBehavior | undefined;
+}, instance: Virtualizer<T, any>) => void;
+export declare const elementScroll: <T extends Element>(offset: number, { adjustments, behavior }: {
+    adjustments?: number | undefined;
+    behavior?: ScrollBehavior | undefined;
+}, instance: Virtualizer<T, any>) => void;
+export interface VirtualizerOptions<TScrollElement extends Element | Window, TItemElement extends Element> {
+    count: number;
+    getScrollElement: () => TScrollElement | null;
+    estimateSize: (index: number) => number;
+    scrollToFn: (offset: number, options: {
+        adjustments?: number;
+        behavior?: ScrollBehavior;
+    }, instance: Virtualizer<TScrollElement, TItemElement>) => void;
+    observeElementRect: (instance: Virtualizer<TScrollElement, TItemElement>, cb: (rect: Rect) => void) => void | (() => void);
+    observeElementOffset: (instance: Virtualizer<TScrollElement, TItemElement>, cb: ObserveOffsetCallBack) => void | (() => void);
+    debug?: boolean;
+    initialRect?: Rect;
+    onChange?: (instance: Virtualizer<TScrollElement, TItemElement>, sync: boolean) => void;
+    measureElement?: (element: TItemElement, entry: ResizeObserverEntry | undefined, instance: Virtualizer<TScrollElement, TItemElement>) => number;
+    overscan?: number;
+    horizontal?: boolean;
+    paddingStart?: number;
+    paddingEnd?: number;
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
+    initialOffset?: number | (() => number);
+    getItemKey?: (index: number) => Key;
+    rangeExtractor?: (range: Range) => Array<number>;
+    scrollMargin?: number;
+    gap?: number;
+    indexAttribute?: string;
+    initialMeasurementsCache?: Array<VirtualItem>;
+    lanes?: number;
+    isScrollingResetDelay?: number;
+    useScrollendEvent?: boolean;
+    enabled?: boolean;
+    isRtl?: boolean;
+}
+export declare class Virtualizer<TScrollElement extends Element | Window, TItemElement extends Element> {
+    private unsubs;
+    options: Required<VirtualizerOptions<TScrollElement, TItemElement>>;
+    scrollElement: TScrollElement | null;
+    targetWindow: (Window & typeof globalThis) | null;
+    isScrolling: boolean;
+    private scrollToIndexTimeoutId;
+    measurementsCache: Array<VirtualItem>;
+    private itemSizeCache;
+    private pendingMeasuredCacheIndexes;
+    scrollRect: Rect | null;
+    scrollOffset: number | null;
+    scrollDirection: ScrollDirection | null;
+    private scrollAdjustments;
+    shouldAdjustScrollPositionOnItemSizeChange: undefined | ((item: VirtualItem, delta: number, instance: Virtualizer<TScrollElement, TItemElement>) => boolean);
+    elementsCache: Map<Key, TItemElement>;
+    private observer;
+    range: {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+    constructor(opts: VirtualizerOptions<TScrollElement, TItemElement>);
+    setOptions: (opts: VirtualizerOptions<TScrollElement, TItemElement>) => void;
+    private notify;
+    private maybeNotify;
+    private cleanup;
+    _didMount: () => () => void;
+    _willUpdate: () => void;
+    private getSize;
+    private getScrollOffset;
+    private getFurthestMeasurement;
+    private getMeasurementOptions;
+    private getMeasurements;
+    calculateRange: () => {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+    private getIndexes;
+    indexFromElement: (node: TItemElement) => number;
+    private _measureElement;
+    resizeItem: (index: number, size: number) => void;
+    measureElement: (node: TItemElement | null | undefined) => void;
+    getVirtualItems: () => VirtualItem[];
+    getVirtualItemForOffset: (offset: number) => VirtualItem | undefined;
+    getOffsetForAlignment: (toOffset: number, align: ScrollAlignment) => number;
+    getOffsetForIndex: (index: number, align?: ScrollAlignment) => readonly [number, "auto"] | readonly [number, "center" | "start" | "end"] | undefined;
+    private isDynamicMode;
+    private cancelScrollToIndex;
+    scrollToOffset: (toOffset: number, { align, behavior }?: ScrollToOffsetOptions) => void;
+    scrollToIndex: (index: number, { align: initialAlign, behavior }?: ScrollToIndexOptions) => void;
+    scrollBy: (delta: number, { behavior }?: ScrollToOffsetOptions) => void;
+    getTotalSize: () => number;
+    private _scrollToOffset;
+    measure: () => void;
+}

package/lib/virtual-list/src/list-item.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type IProps = {
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+};
+declare const ListItem: React.FC<IProps>;
+export default ListItem;

package/lib/virtual-list/src/useVirtual.d.ts

@@ -0,0 +1,5 @@
+import { Virtualizer } from './core';
+import type { PartialKeys, VirtualizerOptions } from './core';
+export * from './core';
+export declare const useVirtualizer: <TScrollElement extends Element, TItemElement extends Element>(options: PartialKeys<VirtualizerOptions<TScrollElement, TItemElement>, "scrollToFn" | "observeElementRect" | "observeElementOffset">) => Virtualizer<TScrollElement, TItemElement>;
+export declare const useWindowVirtualizer: <TItemElement extends Element>(options: PartialKeys<VirtualizerOptions<Window, TItemElement>, "getScrollElement" | "scrollToFn" | "observeElementRect" | "observeElementOffset">) => Virtualizer<Window, TItemElement>;

package/lib/virtual-list/src/utils.d.ts

@@ -0,0 +1,12 @@
+import { AnyFunction } from '../../_utils/types';
+export type NoInfer<A> = [A][A extends any ? 0 : never];
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare function memo<TDeps extends ReadonlyArray<any>, TResult>(getDeps: () => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
+    key: false | string;
+    debug?: () => boolean;
+    onChange?: (result: TResult) => void;
+    initialDeps?: TDeps;
+}): () => TResult;
+export declare function notUndefined<T>(value: T | undefined, msg?: string): T;
+export declare const approxEqual: (a: number, b: number) => boolean;
+export declare const debounce: (targetWindow: Window & typeof globalThis, fn: AnyFunction<any>, ms: number) => (this: any, ...args: Array<any>) => void;

package/lib/virtual-list/src/virtual-list.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { type Virtualizer } from './useVirtual';
+import type { IRecord } from '../../table/src/table/types';
+import ListItem from './list-item';
+type IProps = {
+    height?: number;
+    itemHeight?: number;
+    dataSource?: IRecord[];
+    className?: string;
+    style?: React.CSSProperties;
+    children?: React.ReactNode;
+    renderItem?: (item: IRecord, index: number) => React.ReactNode;
+    onScroll?: (instance: Virtualizer<Element, Element>, sync: boolean) => void;
+};
+export type VirtualListProps = IProps;
+declare const VirtualList: React.FC<IProps> & {
+    Item: typeof ListItem;
+};
+export default VirtualList;

package/lib/virtual-list/style/index.less

@@ -0,0 +1,16 @@
+/*
+ * @Author: 焦质晔
+ * @Date: 2024-12-02 09:06:20
+ * @Last Modified by: 焦质晔
+ * @Last Modified time: 2024-12-02 13:16:55
+ */
+@import '../../style/common';
+
+@prefix-virtual-list: ~'@{qm-prefix}-virtual-list';
+
+.@{prefix-virtual-list} {
+  .reset-container();
+  .list-item {
+    list-style: none;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiaozhiye/qm-design-react",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "A Component Library for React",
   "keywords": [
     "React",