balala-revogrid 1.0.0

package/dist/types/components/attribution/revogr-attribution.d.ts

@@ -0,0 +1,12 @@
+/**
+ * If you’re thinking about removing the attribution, we’d like to share a few thoughts first:
+ * If you’re using RevoGrid in your organization and it’s helping you make money, we depend on your support to keep improving and maintaining RevoGrid under an MIT License.
+ * Before you remove the attribution, please consider how you can support RevoGrid to help keep it running smoothly.
+ * Using RevoGrid for a personal project? Awesome! Feel free to remove the attribution. We appreciate your support.
+ */
+/**
+ * @internal
+ */
+export declare class Attribution {
+    render(): any;
+}

package/dist/types/components/clipboard/revogr-clipboard.d.ts

@@ -0,0 +1,89 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { DataFormat } from "../../types/index";
+/**
+ * This Clipboard provides functionality for handling clipboard events in a web application.
+ */
+export declare class Clipboard {
+    /**
+     * If readonly mode - disabled Paste event
+     */
+    readonly: boolean;
+    /**
+     * Paste 1. Fired before paste applied to the grid
+     * defaultPrevented - if true, paste will be canceled
+     */
+    beforePaste: EventEmitter<{
+        raw: string;
+        isHTML: boolean;
+        event: ClipboardEvent;
+        dataText: string;
+    }>;
+    /**
+     * Paste 2. Fired before paste applied to the grid and after data parsed
+     */
+    beforePasteApply: EventEmitter<{
+        raw: string;
+        parsed: string[][];
+        event: ClipboardEvent;
+    }>;
+    /**
+     * Paste 3. Internal method. When data region is ready pass it to the top.
+     * @property {string[][]} data - data to paste
+     * @property {boolean} defaultPrevented - if true, paste will be canceled
+     */
+    pasteRegion: EventEmitter<string[][]>;
+    /**
+     * Paste 4. Fired after paste applied to the grid
+     * defaultPrevented - if true, paste will be canceled
+     */
+    afterPasteApply: EventEmitter<{
+        raw: string;
+        parsed: string[][];
+        event: ClipboardEvent;
+    }>;
+    /**
+     * Cut 1. Fired before cut triggered
+     * defaultPrevented - if true, cut will be canceled
+     */
+    beforeCut: EventEmitter<{
+        event: ClipboardEvent;
+    }>;
+    /**
+     * Cut 2. Clears region when cut is done
+     */
+    clearRegion: EventEmitter<DataTransfer>;
+    /**
+     * Copy 1. Fired before copy triggered
+     * defaultPrevented - if true, copy will be canceled
+     */
+    beforeCopy: EventEmitter<{
+        event: ClipboardEvent;
+    }>;
+    /**
+     * Copy Method 1. Fired before copy applied to the clipboard from outside.
+     * defaultPrevented - if true, copy will be canceled
+     */
+    beforeCopyApply: EventEmitter<{
+        event: DataTransfer;
+        data?: string[][];
+    }>;
+    /**
+     * Copy 2. Fired when region copied
+     * defaultPrevented - if true, copy will be canceled
+     */
+    copyRegion: EventEmitter<DataTransfer>;
+    onPaste(e: ClipboardEvent): void;
+    /**
+     * Listen to copy event and emit copy region event
+     */
+    copyStarted(e: ClipboardEvent): void;
+    /**
+     * Listen to cut event and emit cut region event
+     */
+    cutStarted(e: ClipboardEvent): void;
+    doCopy(e: DataTransfer, data?: DataFormat[][]): Promise<void>;
+    parserCopy(data: DataFormat[][]): string;
+    private textParse;
+    private htmlParse;
+    private getData;
+}

package/dist/types/components/data/cell-renderer.d.ts

@@ -0,0 +1,12 @@
+import { type VNode, EventEmitter } from '../../stencil-public-runtime';
+import { DragStartEvent, CellTemplateProp } from "../../types/index";
+interface RenderProps {
+    schemaModel: CellTemplateProp;
+    additionalData?: any;
+    dragStartCell?: EventEmitter<DragStartEvent>;
+}
+export declare const CellRenderer: ({ renderProps, cellProps, }: {
+    renderProps: RenderProps;
+    cellProps: any;
+}) => VNode;
+export {};

package/dist/types/components/data/column.service.d.ts

@@ -0,0 +1,65 @@
+import { DSourceState } from "../../store/index";
+import { Observable } from '../../utils';
+import { DimensionCols, DimensionRows, RowDrag, ColumnRegular, DataType, CellProps, ColumnDataSchemaModel, ColumnProp, DataLookup, DataFormat, ChangedRange, OldNewRangeMapping, Cell, RangeArea, BeforeSaveDataDetails, EditorCtr, Editors, CellTemplateProp } from "../../types/index";
+export type ColumnStores = {
+    [T in DimensionCols]: Observable<DSourceState<ColumnRegular, DimensionCols>>;
+};
+export type RowStores = {
+    [T in DimensionRows]: Observable<DSourceState<DataType, DimensionRows>>;
+};
+export declare function getCellEditor(column: Pick<ColumnRegular, 'editor'> | undefined, editors?: Editors): EditorCtr | undefined;
+export default class ColumnService {
+    private dataStore;
+    private source;
+    private unsubscribe;
+    private loggedMissingCols;
+    private overrideColumns;
+    get columns(): ColumnRegular[];
+    setOverrideColumns(columns: ColumnRegular[] | null): void;
+    hasGrouping: boolean;
+    type: DimensionCols;
+    constructor(dataStore: Observable<DSourceState<DataType, DimensionRows>>, source: Observable<DSourceState<ColumnRegular, DimensionCols>>);
+    private getColumnByIndex;
+    private checkGrouping;
+    isReadOnly(r: number, c: number): boolean;
+    mergeProperties(r: number, c: number, defaultProps: CellProps, schemaModel: CellTemplateProp): CellProps;
+    getRowClass(r: number, prop: string): string;
+    getSaveData(rowIndex: number, colIndex: number, val?: string): BeforeSaveDataDetails;
+    /**
+     * Get cell data model for given rowIndex and colIndex
+     * Used to pass data to editor/renderer
+     */
+    rowDataModel(rowIndex: number, colIndex: number): ColumnDataSchemaModel;
+    getRangeData(d: ChangedRange, columns: ColumnRegular[]): {
+        changed: DataLookup;
+        mapping: OldNewRangeMapping;
+    };
+    getTransformedDataToApply(start: Cell, data: DataFormat[][]): {
+        changed: DataLookup;
+        range: RangeArea | null;
+    };
+    getRangeStaticData(d: RangeArea, value: DataFormat): DataLookup;
+    getRangeTransformedToProps(d: RangeArea, store: Observable<DSourceState<DataType, DimensionRows>>): {
+        prop: ColumnProp;
+        rowIndex: number;
+        colIndex: number;
+        model?: DataType;
+        colType: DimensionCols;
+        type: DimensionRows;
+    }[];
+    copyRangeArray(range: RangeArea, store: Observable<DSourceState<DataType, DimensionRows>>): {
+        data: any[][];
+        mapping: {
+            [rowIndex: number]: {
+                [colProp: string]: any;
+                [colProp: number]: any;
+            };
+        };
+    };
+    destroy(): void;
+}
+/**
+ * Checks if the given rowDrag is a service for dragging rows.
+ */
+export declare function isRowDragService(rowDrag: RowDrag, model: ColumnDataSchemaModel): boolean;
+export declare function doPropMerge(existing: CellProps, extra: CellProps): CellProps;

package/dist/types/components/data/revogr-data.d.ts

@@ -0,0 +1,132 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type DSourceState } from "../../store/index";
+import type { AllDimensionType, CellTemplateProp, DimensionCols, DimensionRows } from "../../types/index";
+import type { ViewportState, DimensionSettingsState, BeforeRowRenderEvent, Providers, ColumnRegular, DataType, BeforeCellRenderEvent, DragStartEvent, VirtualPositionItem, SelectionStoreState } from "../../types/index";
+import type { Observable } from '../../utils';
+/**
+ * This component is responsible for rendering data
+ * Rows, columns, groups and cells
+ */
+export declare class RevogrData {
+    /**
+     * Readonly mode
+     */
+    readonly: boolean;
+    /**
+     * Range allowed
+     */
+    range: boolean;
+    /**
+     * Defines property from which to read row class
+     */
+    rowClass: string;
+    /**
+     * Additional data to pass to renderer
+     * Used in plugins such as vue or react to pass root app entity to cells
+     */
+    additionalData: any;
+    /**
+     * Padding depth for grouping rows (in pixels per depth level)
+     */
+    paddingDepth?: number;
+    /** Stores */
+    /** Selection, range, focus for row selection */
+    rowSelectionStore: Observable<SelectionStoreState>;
+    /** Viewport Y */
+    viewportRow: Observable<ViewportState>;
+    /** Viewport X */
+    viewportCol: Observable<ViewportState>;
+    /** Dimension settings Y */
+    dimensionRow: Observable<DimensionSettingsState>;
+    /** Static stores, not expected to change during component lifetime */
+    /**
+     * Column source
+     */
+    colData: Observable<DSourceState<ColumnRegular, DimensionCols>>;
+    /**
+     * Data rows source
+     */
+    dataStore: Observable<DSourceState<DataType, DimensionRows>>;
+    /**
+     * Row data type
+     */
+    type: DimensionRows;
+    /**
+     * Column data type
+     */
+    colType: DimensionCols | 'rowHeaders';
+    /**
+     * Prevent rendering until job is done.
+     * Can be used for initial rendering performance improvement.
+     * When several plugins require initial rendering this will prevent double initial rendering.
+     */
+    jobsBeforeRender: (Promise<any> | (() => Promise<any>))[];
+    /**
+     * Unique identifier for the data component
+     * Used for tracking and debugging purposes
+     */
+    uniqueId?: any;
+    /**
+     * Whether there are colPinEnd columns in the grid
+     * Used to determine which column should get the last-column class
+     */
+    hasColPinEnd?: boolean;
+    /**
+     * Whether there are rgCol columns in the grid
+     * Used to determine which column should get the last-column class
+     */
+    hasRgCol?: boolean;
+    /**
+     * Before each row render
+     */
+    beforerowrender: EventEmitter<BeforeRowRenderEvent>;
+    /**
+     * When data render finished for the designated type
+     */
+    afterrender: EventEmitter<{
+        type: DimensionRows;
+        colType: DimensionCols | 'rowHeaders';
+    }>;
+    /**
+     * Before each cell render function. Allows to override cell properties
+     */
+    beforeCellRender: EventEmitter<BeforeCellRenderEvent<CellTemplateProp>>;
+    /**
+     * Before data render
+     */
+    beforeDataRender: EventEmitter<AllDimensionType>;
+    /**
+     * Event emitted on cell drag start
+     */
+    dragStartCell: EventEmitter<DragStartEvent>;
+    /**
+     * Pointed cell update.
+     */
+    updateCell(e: {
+        row: number;
+        col: number;
+    }): Promise<void>;
+    element: Element;
+    providers: Providers;
+    private columnService;
+    private rowHighlightPlugin;
+    /**
+     * Rendered rows - virtual index vs vnode
+     */
+    private renderedRows;
+    private rangeUnsubscribe;
+    private lastMismatchKey;
+    private lastStableRows;
+    private lastStableCols;
+    private lastStableColumns;
+    private lastRenderStateKey;
+    onDataStoreChange(): void;
+    onColDataChange(): void;
+    onStoreChange(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillRender(): Promise<any[]>;
+    componentDidRender(): void;
+    render(): any;
+    triggerBeforeCellRender(model: CellTemplateProp, row: VirtualPositionItem, column: VirtualPositionItem): CustomEvent<BeforeCellRenderEvent<CellTemplateProp>>;
+}

package/dist/types/components/data/row-highlight.plugin.d.ts

@@ -0,0 +1,10 @@
+import { type VNode } from '../../stencil-public-runtime';
+import { RangeArea } from "../../types/index";
+/**
+ * Class is responsible for highlighting rows in a table.
+ */
+export declare class RowHighlightPlugin {
+    private currentRange;
+    selectionChange(e: RangeArea, renderedRows: Map<number, VNode>): void;
+    isRowFocused(y: number): boolean | null;
+}

package/dist/types/components/data/row-renderer.d.ts

@@ -0,0 +1,13 @@
+import { type VNode } from '../../stencil-public-runtime';
+import { JSXBase } from '../../stencil-public-runtime';
+export interface RowProps extends JSXBase.HTMLAttributes {
+    size: number;
+    start: number;
+    index: number;
+    rowClass?: string;
+    depth?: number;
+    paddingDepth?: number;
+}
+export declare const PADDING_DEPTH = 10;
+declare const RowRenderer: ({ rowClass, index, size, start, depth, paddingDepth }: RowProps, cells: VNode[]) => any;
+export default RowRenderer;

package/dist/types/components/editors/edit.utils.d.ts

@@ -0,0 +1,3 @@
+import { EditorCtrConstructible } from "../../types/index";
+export declare function isEditInput(el?: HTMLElement): boolean;
+export declare function isEditorCtrConstructible(editor: any): editor is EditorCtrConstructible;

package/dist/types/components/editors/revogr-edit.d.ts

@@ -0,0 +1,63 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ColumnDataSchemaModel } from "../../types/index";
+import { EditCell, EditorCtr, SaveDataDetails } from "../../types/index";
+/**
+ * Represents a cell editor in a grid.
+ * It manages the editing of cells by handling events, saving data, rendering the editor UI,
+ * and managing the lifecycle of the editor instance.
+ */
+export declare class RevoEdit {
+    /**
+     * Cell to edit data.
+     */
+    editCell: EditCell;
+    /**
+     * Column data for editor.
+     */
+    column: ColumnDataSchemaModel | null;
+    /**
+     * Custom editors register
+     */
+    editor: EditorCtr | null;
+    /**
+     * Save on editor close. Defines if data should be saved on editor close.
+     */
+    saveOnClose: boolean;
+    /**
+     * Additional data to pass to renderer
+     */
+    additionalData: any;
+    /**
+     * Cell edit event initiator, first in the cellEdit event chain
+     */
+    cellEdit: EventEmitter<SaveDataDetails>;
+    /**
+     * Close editor event
+     * pass true if requires focus next
+     */
+    closeEdit: EventEmitter<boolean | undefined>;
+    /** Edit session editor */
+    element: HTMLElement;
+    private currentEditor;
+    private preventSaveOnClose;
+    /**
+     * Cancel pending changes flag. Editor will be closed without autosave.
+     */
+    cancelChanges(): Promise<void>;
+    /**
+     * Before editor got disconnected.
+     * Can be triggered multiple times before actual disconnect.
+     */
+    beforeDisconnect(): Promise<void>;
+    onAutoSave(): void;
+    /**
+     * Callback triggered when cell editor saved.
+     * Closes editor when called.
+     * @param preventFocus - if true, editor will not be closed & next cell will not be focused.
+     */
+    onSave(val?: any, preventFocus?: boolean): void;
+    componentWillRender(): void;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    render(): any;
+}

package/dist/types/components/editors/text-editor.d.ts

@@ -0,0 +1,43 @@
+import { type VNode, h as createElement } from '../../stencil-public-runtime';
+import type { EditCell, EditorBase, ColumnDataSchemaModel } from "../../types/index";
+/**
+ * Represents a cell editor in a grid.
+ *
+ * It's a good place to start with your own editor.
+ * It manages the editing of cells by handling events, saving data, rendering the editor UI, and managing the lifecycle of the editor instance.
+ */
+/**
+ * Callback triggered on cell editor save
+ * Closes editor when called
+ * @param preventFocus - if true editor will not be closed and next cell will not be focused
+ */
+export type SaveCallback = (value: any, preventFocus: boolean) => void;
+export declare class TextEditor implements EditorBase {
+    data: ColumnDataSchemaModel;
+    private saveCallback?;
+    editInput: HTMLInputElement | null;
+    element: Element | null;
+    editCell?: EditCell;
+    constructor(data: ColumnDataSchemaModel, saveCallback?: SaveCallback | undefined);
+    /**
+     * Callback triggered on cell editor render
+     */
+    componentDidRender(): Promise<void>;
+    onKeyDown(e: KeyboardEvent): void;
+    /**
+     * IMPORTANT: Prevent scroll glitches when editor is closed and focus is on current input element.
+     */
+    beforeDisconnect(): void;
+    /**
+     * Get value from input
+     */
+    getValue(): string | undefined;
+    /**
+     * Render method for Editor plugin.
+     * Renders input element with passed data from cell.
+     * @param {Function} h - h function from stencil render.
+     * @param {Object} _additionalData - additional data from plugin.
+     * @returns {VNode} - input element.
+     */
+    render(h: typeof createElement, _additionalData: any): VNode | VNode[];
+}

package/dist/types/components/extra/revogr-extra.d.ts

@@ -0,0 +1,38 @@
+import { VNode } from '../../stencil-public-runtime';
+import type { ExtraNodeFuncConfig } from "../../types/index";
+/**
+ * Contains extra elements for stencil components.
+ * Performs rendering and updates for external components.
+ *
+ * @example
+ * In Plugins if you want to add extra elements to grid and use stenciljs vnodes reactivity:
+ * function paginationPanel(this: PaginationPlugin, config: { refresh: () => void }) {
+ *    // use `config.refresh()` for component to re-render
+ *    return h('div')
+ * }
+ *
+ * revogrid.registerVNode = [
+ *    ...existingNodes,
+ *     paginationPanel.bind(this)
+ * ];
+
+
+/**
+ * @internal
+ */
+export declare class RevoGridExtra {
+    /**
+     * Nodes to render
+     */
+    nodes: (VNode | ((c: ExtraNodeFuncConfig) => VNode))[];
+    /**
+     * Force component to re-render
+     */
+    update: number;
+    /**
+     * Refreshes the extra component. Useful if you want to manually
+     * force the component to re-render.
+     */
+    refresh(): Promise<void>;
+    render(): any[];
+}

package/dist/types/components/grouping-overlay/revogr-grouping-overlay.d.ts

@@ -0,0 +1,71 @@
+import type { DimensionRows, DimensionCols, DataType, ColumnRegular, ViewportState, DimensionSettingsState } from "../../types/index";
+import type { Observable } from '../../utils';
+import { type DSourceState } from "../../store/index";
+import type { GetGroupSelectionFunc } from '../../plugins/groupingRow/grouping.row.types';
+export declare class RevogrGroupingOverlay {
+    dataStore: Observable<DSourceState<DataType, DimensionRows>>;
+    colData: Observable<DSourceState<ColumnRegular, DimensionCols>>;
+    viewportRow: Observable<ViewportState>;
+    viewportCol: Observable<ViewportState>;
+    dimensionRow: Observable<DimensionSettingsState>;
+    type: DimensionRows;
+    colType: DimensionCols;
+    additionalData: any;
+    rowClass: string;
+    /** 获取分组选中信息的函数 */
+    getGroupSelection?: GetGroupSelectionFunc;
+    /** Padding depth for grouping rows (in pixels per depth level) */
+    paddingDepth?: number;
+    element: HTMLElement;
+    private groupRows;
+    private dataRows;
+    private unsubscribers;
+    private providers;
+    /** 缓存的选中行索引 */
+    private cachedSelectedIndices;
+    /** 上次解析的选中行属性值 */
+    private lastSelectedRowsAttr;
+    /** 上次的 viewport items 引用（用于变化检测） */
+    private lastRowItems;
+    /** 上次的 col items 引用 */
+    private lastColItems;
+    /** RAF 节流标记 */
+    private updateScheduled;
+    /** MutationObserver 用于监听选中状态变化 */
+    private selectionObserver;
+    /** ResizeObserver 用于监听表格宽度变化 */
+    private resizeObserver;
+    onDataChange(): void;
+    /**
+     * 刷新分组行显示，用于选中状态变化后更新选中数量
+     */
+    refresh(): Promise<void>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * 设置 ResizeObserver 监听表格宽度变化
+     */
+    private setupResizeObserver;
+    /**
+     * 设置 MutationObserver 监听选中状态变化
+     */
+    private setupSelectionObserver;
+    /**
+     * 使用 RAF 节流的更新调度
+     */
+    private scheduleUpdate;
+    /**
+     * 更新选中行索引缓存
+     */
+    private updateSelectedIndicesCache;
+    /**
+     * 获取选中行索引（使用缓存）
+     */
+    private getSelectedRowIndices;
+    /**
+     * 立即更新分组行（带变化检测）
+     * @param forceUpdate 是否强制更新，忽略变化检测
+     */
+    updateGroupRowsImmediate(forceUpdate?: boolean): Promise<void>;
+    render(): any;
+}

package/dist/types/components/header/header-cell-renderer.d.ts

@@ -0,0 +1,10 @@
+import { type FunctionalComponent } from '../../stencil-public-runtime';
+import { ResizableElementHTMLAttributes } from './resizable.element';
+import { ColumnTemplateProp } from "../../types/index";
+export declare const ON_COLUMN_CLICK = "columnclick";
+export declare const HEADER_NOT_DRAGGABLE_CLASS = "rgHeaderCell-not-draggable";
+export declare const HeaderCellRenderer: FunctionalComponent<{
+    props: ResizableElementHTMLAttributes;
+    additionalData: any;
+    data?: ColumnTemplateProp;
+}>;

package/dist/types/components/header/header-group-renderer.d.ts

@@ -0,0 +1,17 @@
+import { h } from '../../stencil-public-runtime';
+import { Group } from "../../store/index";
+import type { ProvidersColumns } from "../../types/index";
+import { ResizeEvent, ResizeProps } from './resizable.directive';
+export type HeaderGroupRendererProps = {
+    start: number;
+    end: number;
+    group: Group;
+    providers: ProvidersColumns;
+    additionalData: any;
+    canResize?: boolean;
+    /** 是否是最后一列 */
+    isLastColumn?: boolean;
+    onResize?(e: ResizeEvent): void;
+} & Partial<Pick<ResizeProps, 'active'>>;
+declare const HeaderGroupRenderer: (p: HeaderGroupRendererProps) => ReturnType<typeof h>;
+export default HeaderGroupRenderer;

package/dist/types/components/header/header-renderer.d.ts

@@ -0,0 +1,24 @@
+import { h } from '../../stencil-public-runtime';
+import type { VirtualPositionItem, ColumnTemplateProp, InitialHeaderClick, RangeArea } from "../../types/index";
+import { ResizeEvent, ResizeProps } from './resizable.directive';
+export type HeaderRenderProps = {
+    column: VirtualPositionItem;
+    additionalData: any;
+    data: ColumnTemplateProp;
+    range?: RangeArea | null;
+    canResize?: boolean;
+    canFilter?: boolean;
+    /** 是否为合并单元格（非分组列跨越分组行） */
+    merged?: boolean;
+    /** 分组深度 */
+    groupingDepth?: number;
+    /** 是否属于编组 */
+    isGrouped?: boolean;
+    /** 是否是最后一列 */
+    isLastColumn?: boolean;
+    onResize?(e: ResizeEvent): void;
+    onClick?(data: InitialHeaderClick): void;
+    onDblClick?(data: InitialHeaderClick): void;
+} & Partial<Pick<ResizeProps, 'active'>>;
+declare const HeaderRenderer: (p: HeaderRenderProps) => ReturnType<typeof h>;
+export default HeaderRenderer;

package/dist/types/components/header/resizable.directive.d.ts

@@ -0,0 +1,60 @@
+export type ResizeProps = {
+    active: ('r' | 'rb' | 'b' | 'lb' | 'l' | 'lt' | 't' | 'rt')[];
+    fitParent: boolean;
+    minWidth: number;
+    minHeight: number;
+    disableAttributes: ('l' | 't' | 'w' | 'h')[];
+    maxWidth?: number;
+    maxHeight?: number;
+    onResize?(e: ResizeEvent): void;
+};
+export type ResizeEvent = {
+    eventName: string;
+    changedX?: number;
+    changedY?: number;
+    width?: number;
+    height?: number;
+};
+export declare enum ResizeEvents {
+    start = "resize:start",
+    move = "resize:move",
+    end = "resize:end"
+}
+export declare class ResizeDirective {
+    private initialProps;
+    private $event?;
+    private $el;
+    private props;
+    private minW;
+    private minH;
+    private maxW;
+    private maxH;
+    private startMouseX;
+    private startMouseY;
+    private width;
+    private height;
+    private changeX;
+    private changeY;
+    private parent;
+    private resizeState;
+    private activeResizer?;
+    private disableCalcMap;
+    private mouseMoveFunc;
+    private mouseUpFunc;
+    private handleRightClickFunc;
+    private handleContextMenuFunc;
+    constructor(initialProps: Partial<ResizeProps>, $event?: ((e: ResizeEvent) => void) | undefined);
+    set($el: HTMLElement): void;
+    emitEvent(eventName: string, additionalOptions?: any): void;
+    private static isTouchEvent;
+    handleMove(event: MouseEvent | TouchEvent): void;
+    handleDown(event: MouseEvent | TouchEvent): void;
+    handleUp(e: MouseEvent): void;
+    private setInitials;
+    private dropInitial;
+    private bindMove;
+    private unbindMove;
+    private handleRightClick;
+    private handleContextMenu;
+    private cancelResize;
+}