flexlayout-react 0.8.18 → 0.9.0

package/types/view/Tab.d.ts

@@ -1,11 +1,10 @@
 import { TabNode } from "../model/TabNode";
-import { LayoutInternal } from "./Layout";
+import { LayoutController } from "./layout/LayoutInternal";
 /** @internal */
 export interface ITabProps {
-    layout: LayoutInternal;
-    node: TabNode;
+    controller: LayoutController;
+    tabNode: TabNode;
     selected: boolean;
-    path: string;
 }
 /** @internal */
 export declare const Tab: (props: ITabProps) => import("react/jsx-runtime").JSX.Element;

package/types/view/TabButton.d.ts

@@ -1,9 +1,9 @@
 import { TabNode } from "../model/TabNode";
-import { LayoutInternal } from "./Layout";
+import { LayoutController } from "./layout/LayoutInternal";
 /** @internal */
 export interface ITabButtonProps {
-    layout: LayoutInternal;
-    node: TabNode;
+    controller: LayoutController;
+    tabNode: TabNode;
     selected: boolean;
     path: string;
 }

package/types/view/TabButtonStamp.d.ts

@@ -1,9 +1,9 @@
 import { TabNode } from "../model/TabNode";
-import { LayoutInternal } from "./Layout";
+import { LayoutController } from "./layout/LayoutInternal";
 /** @internal */
 export interface ITabButtonStampProps {
-    node: TabNode;
-    layout: LayoutInternal;
+    tabNode: TabNode;
+    controller: LayoutController;
 }
 /** @internal */
 export declare const TabButtonStamp: (props: ITabButtonStampProps) => import("react/jsx-runtime").JSX.Element;

package/types/view/TabContentRenderer.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import { Rect } from "../model/Rect";
+import { LayoutController } from "./layout/LayoutInternal";
+import { TabNode } from "../model/TabNode";
+export interface ITabContentRenderProps {
+    controller: LayoutController;
+    tabNode: TabNode;
+    rect: Rect;
+    windowId: string;
+    visible: boolean;
+    fullRedrawRevision: number;
+    parentRedrawRevision: number;
+}
+export declare const TabContentRenderer: React.MemoExoticComponent<({ controller, tabNode }: ITabContentRenderProps) => import("react/jsx-runtime").JSX.Element>;

package/types/view/TabLayout.d.ts

@@ -0,0 +1,12 @@
+import { TabNode } from "../model/TabNode";
+export interface ITabLayoutProps {
+    tabNode: TabNode;
+}
+/**
+ * Component that can be used within the factory to render a tabs defined sublayout.
+ * This allows the sublayout to be surrounded by other controls, e.g. a header and footer bars
+ *
+ * @category Components
+ * @group Main Layout
+ */
+export declare const TabLayout: (props: ITabLayoutProps) => import("react/jsx-runtime").JSX.Element | undefined;

package/types/view/TabOverflowHook.d.ts

@@ -1,10 +1,10 @@
 import * as React from "react";
 import { TabSetNode } from "../model/TabSetNode";
 import { BorderNode } from "../model/BorderNode";
-import { Orientation } from "../Orientation";
-import { LayoutInternal } from "./Layout";
+import { Orientation } from "../model/Orientation";
+import { LayoutController } from "./layout/LayoutInternal";
 /** @internal */
-export declare const useTabOverflow: (layout: LayoutInternal, node: TabSetNode | BorderNode, orientation: Orientation, tabStripRef: React.RefObject<HTMLElement | null>, miniScrollRef: React.RefObject<HTMLElement | null>, tabClassName: string) => {
+export declare const useTabOverflow: (controller: LayoutController, node: TabSetNode | BorderNode, orientation: Orientation, tabStripRef: React.RefObject<HTMLElement | null>, miniScrollRef: React.RefObject<HTMLElement | null>, tabClassName: string) => {
     selfRef: React.RefObject<HTMLDivElement | null>;
     userControlledPositionRef: React.RefObject<boolean>;
     onScroll: () => void;

package/types/view/TabSet.d.ts

@@ -1,9 +1,9 @@
 import { TabSetNode } from "../model/TabSetNode";
-import { LayoutInternal } from "./Layout";
+import { LayoutController } from "./layout/LayoutInternal";
 /** @internal */
 export interface ITabSetProps {
-    layout: LayoutInternal;
-    node: TabSetNode;
+    controller: LayoutController;
+    tabsetNode: TabSetNode;
 }
 /** @internal */
 export declare const TabSet: (props: ITabSetProps) => import("react/jsx-runtime").JSX.Element;

package/types/view/Utils.d.ts

@@ -1,21 +1,24 @@
 import * as React from "react";
 import { Node } from "../model/Node";
 import { TabNode } from "../model/TabNode";
-import { LayoutInternal } from "./Layout";
+import { LayoutController } from "./layout/LayoutInternal";
+import { Layout } from "../model/Layout";
 /** @internal */
 export declare function isDesktop(): boolean;
 /** @internal */
-export declare function getRenderStateEx(layout: LayoutInternal, node: TabNode, iconAngle?: number): {
+export declare function getRenderStateEx(controller: LayoutController, tabNode: TabNode, iconAngle?: number): {
     leading: import("react/jsx-runtime").JSX.Element | undefined;
     content: string | Iterable<React.ReactNode>;
     name: string;
-    buttons: any[];
+    buttons: React.ReactNode[];
 };
 /** @internal */
 export declare function isAuxMouseEvent(event: React.MouseEvent<HTMLElement, MouseEvent> | React.TouchEvent<HTMLElement>): boolean;
 export declare function enablePointerOnIFrames(enable: boolean, currentDocument: Document): void;
 export declare function getElementsByTagName(tag: string, currentDocument: Document): Element[];
+export declare let Utils_dragging: boolean;
 export declare function startDrag(doc: Document, event: React.PointerEvent<HTMLElement>, drag: (x: number, y: number) => void, dragEnd: () => void, dragCancel: () => void): void;
-export declare function canDockToWindow(node: Node): boolean;
+export declare function findParentLayout(layout: Layout): Layout | undefined;
+export declare function canDockToLayout(node: Node, layout: Layout): boolean;
 export declare function copyInlineStyles(source: HTMLElement, target: HTMLElement): boolean;
 export declare function isSafari(): boolean;

package/types/view/layout/BorderContainer.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { LayoutController } from "./LayoutInternal";
+export interface IBorderContainerProps {
+    controller: LayoutController;
+    inner: React.ReactNode;
+}
+export declare const BorderContainer: ({ controller, inner }: IBorderContainerProps) => import("react/jsx-runtime").JSX.Element;

package/types/view/layout/DragDropManager.d.ts

@@ -0,0 +1,48 @@
+import * as React from "react";
+import { Node } from "../../model/Node";
+import { TabNode } from "../../model/TabNode";
+import { TabSetNode } from "../../model/TabSetNode";
+import { IDraggable } from "../../model/IDraggable";
+import { IJsonTabNode } from "../../model/IJsonModel";
+import { LayoutController } from "./LayoutInternal";
+export declare class DragDropManager {
+    private static dragState;
+    private _controller;
+    private _dragEnterCount;
+    private _dragging;
+    private _active;
+    private _dropInfo;
+    private _outlineDiv?;
+    private _mainController;
+    constructor(controller: LayoutController);
+    addTabWithDragAndDrop(event: DragEvent, json: IJsonTabNode, onDrop?: (node?: Node, event?: React.DragEvent<HTMLElement>) => void): void;
+    moveTabWithDragAndDrop(event: DragEvent, node: (TabNode | TabSetNode)): void;
+    setDragNode: (event: DragEvent, node: Node & IDraggable) => void;
+    setDragComponent(event: DragEvent, component: React.ReactNode, x: number, y: number): void;
+    updateActive(event: React.DragEvent<HTMLElement>): void;
+    setActive(active: boolean, event: React.DragEvent<HTMLElement>): void;
+    onDragEnterRaw: (event: React.DragEvent<HTMLElement>) => void;
+    onDragLeaveRaw: (event: React.DragEvent<HTMLElement>) => void;
+    clearDragMain(): void;
+    clearDragLocal(): void;
+    clearDragLocalVisuals(): void;
+    onDragEnter: (event: React.DragEvent<HTMLElement>) => void;
+    onDragOver: (event: React.DragEvent<HTMLElement>) => void;
+    onDragLeave: (event: React.DragEvent<HTMLElement>) => void;
+    onDrop: (event: React.DragEvent<HTMLElement>) => void;
+    getDragEnterCount(): number;
+    isDragging(): boolean;
+}
+export declare enum DragSource {
+    Internal = "internal",
+    External = "external",
+    Add = "add"
+}
+export declare class DragState {
+    readonly mainLayoutController: LayoutController;
+    readonly dragSource: DragSource;
+    readonly dragNode: Node & IDraggable | undefined;
+    readonly dragJson: IJsonTabNode | undefined;
+    readonly fnNewNodeDropped: ((node?: Node, event?: React.DragEvent<HTMLElement>) => void) | undefined;
+    constructor(mainLayoutController: LayoutController, dragSource: DragSource, dragNode: Node & IDraggable | undefined, dragJson: IJsonTabNode | undefined, fnNewNodeDropped: ((node?: Node, event?: React.DragEvent<HTMLElement>) => void) | undefined);
+}

package/types/view/layout/EdgeIndicators.d.ts

@@ -0,0 +1,5 @@
+import { LayoutController } from "./LayoutInternal";
+export interface IEdgeIndicatorsProps {
+    controller: LayoutController;
+}
+export declare const EdgeIndicators: ({ controller }: IEdgeIndicatorsProps) => import("react/jsx-runtime").JSX.Element;

package/types/view/layout/FloatingWindowContainer.d.ts

@@ -0,0 +1,5 @@
+import { LayoutController } from "./LayoutInternal";
+export interface IFloatingWindowContainerProps {
+    controller: LayoutController;
+}
+export declare const FloatingWindowContainer: ({ controller }: IFloatingWindowContainerProps) => import("react/jsx-runtime").JSX.Element;

package/types/view/layout/LayoutInternal.d.ts

@@ -0,0 +1,151 @@
+import * as React from "react";
+import { DockLocation } from "../../model/DockLocation";
+import { I18nLabel } from "../I18nLabel";
+import { Rect } from "../../model/Rect";
+import { Action } from "../../model/Actions";
+import { BorderNode } from "../../model/BorderNode";
+import { IJsonTabNode } from "../../model/IJsonModel";
+import { Model } from "../../model/Model";
+import { Node } from "../../model/Node";
+import { TabNode } from "../../model/TabNode";
+import { TabSetNode } from "../../model/TabSetNode";
+import { Layout as ModelLayout } from "../../model/Layout";
+import { DragDropManager } from "./DragDropManager";
+import { ITabSetRenderValues, ITabRenderValues, IIcons } from "./LayoutTypes";
+import { ILayoutProps } from "../Layout";
+/** @internal */
+export interface ILayoutInternalProps extends ILayoutProps {
+    parentRedrawRevision: number;
+    layoutId?: string;
+    mainLayoutController?: LayoutController;
+}
+/** @internal */
+export interface ILayoutInternalState {
+    rect: Rect;
+    editingTab?: TabNode;
+    portal?: React.ReactPortal;
+    showEdges: boolean;
+    showOverlay: boolean;
+    calculatedBorderBarSize: number;
+    layoutRedrawRevision: number;
+    fullRedrawRevision: number;
+    showHiddenBorder: DockLocation;
+    splitterSize: number;
+}
+/** @internal */
+export declare const LayoutInternal: React.ForwardRefExoticComponent<ILayoutInternalProps & React.RefAttributes<LayoutController>>;
+/** @internal */
+export declare class LayoutController {
+    private static Windows;
+    private _props;
+    private _state;
+    private _setState;
+    private _layoutRef;
+    private _moveablesRef;
+    private _findBorderBarSizeRef;
+    private _mainRef;
+    private _orderedTabIds;
+    private _orderedTabMoveableIds;
+    private _moveableElementMap;
+    private _currentDocument?;
+    private _currentWindow?;
+    private _supportsPopout;
+    private _popoutURL;
+    private _icons;
+    private _dragDropManager;
+    private _layoutId;
+    private _layout;
+    private _mainController?;
+    private _popoutWindowName;
+    private _cachedLayoutDOMRect;
+    private _reLayout;
+    constructor(props: ILayoutInternalProps, state: ILayoutInternalState, setState: (update: Partial<ILayoutInternalState> | ((prevState: ILayoutInternalState, props: ILayoutInternalProps) => Partial<ILayoutInternalState>)) => void);
+    renderLayout(): import("react/jsx-runtime").JSX.Element;
+    renderTabContainers(): Map<string, React.ReactNode>;
+    renderTabContents(): Map<string, React.ReactNode>;
+    renderMetricsElements(): import("react/jsx-runtime").JSX.Element;
+    renderTabStamps(): React.ReactNode[];
+    createMoveableDivs(): void;
+    getMoveablesDiv(): HTMLDivElement | null;
+    getMoveableElement(id: string): HTMLElement;
+    tidyMoveablesMap(): void;
+    redrawLayout(): void;
+    redrawLayoutAndTabContent(isLayoutRevision?: boolean): void;
+    doAction(action: Action): Node | undefined;
+    updateRect: () => void;
+    onModelChange: (action: Action) => void;
+    reorderComponents(components: Map<string, React.ReactNode>, ids: string[]): React.ReactNode[];
+    checkForBorderToShow(x: number, y: number): void;
+    updateLayoutMetrics: () => void;
+    addTabWithDragAndDrop(event: DragEvent, json: IJsonTabNode, onDrop?: (node?: Node, event?: React.DragEvent<HTMLElement>) => void): void;
+    moveTabWithDragAndDrop(event: DragEvent, node: (TabNode | TabSetNode)): void;
+    setDragComponent(event: DragEvent, component: React.ReactNode, x: number, y: number): void;
+    getProps(): ILayoutInternalProps;
+    setProps(value: ILayoutInternalProps): void;
+    getState(): ILayoutInternalState;
+    setStateRaw(value: ILayoutInternalState): void;
+    setState(update: Partial<ILayoutInternalState> | ((prevState: ILayoutInternalState, props: ILayoutInternalProps) => Partial<ILayoutInternalState>)): void;
+    setSetState(value: (update: Partial<ILayoutInternalState> | ((prevState: ILayoutInternalState, props: ILayoutInternalProps) => Partial<ILayoutInternalState>)) => void): void;
+    getLayoutRef(): React.RefObject<HTMLDivElement | null>;
+    setLayoutRef(value: React.RefObject<HTMLDivElement | null>): void;
+    getMoveablesRef(): React.RefObject<HTMLDivElement | null>;
+    setMoveablesRef(value: React.RefObject<HTMLDivElement | null>): void;
+    getFindBorderBarSizeRef(): React.RefObject<HTMLDivElement | null>;
+    setFindBorderBarSizeRef(value: React.RefObject<HTMLDivElement | null>): void;
+    getMainRef(): React.RefObject<HTMLDivElement | null>;
+    setMainRef(value: React.RefObject<HTMLDivElement | null>): void;
+    getOrderedTabIds(): string[];
+    getOrderedTabMoveableIds(): string[];
+    getCurrentDocument(): Document | undefined;
+    setCurrentDocument(value: Document | undefined): void;
+    getCurrentWindow(): Window | undefined;
+    setCurrentWindow(value: Window | undefined): void;
+    getWindowId(): string | undefined;
+    isSupportsPopout(): boolean;
+    getPopoutURL(): string;
+    getIcons(): IIcons;
+    getDragDropManager(): DragDropManager;
+    getLayoutId(): string;
+    getLayout(): ModelLayout;
+    setLayout(value: ModelLayout): void;
+    getMainController(): LayoutController | undefined;
+    isMainLayout(): boolean;
+    getPopoutWindowName(): string;
+    isReLayout(): boolean;
+    setReLayout(value: boolean): void;
+    getBoundingClientRect(div: HTMLElement): Rect;
+    getMoveableContainer(): HTMLDivElement | null;
+    getClassName: (defaultClassName: string) => string;
+    getDomRect(): Rect;
+    getRootDiv(): HTMLDivElement | null;
+    getMainElement(): HTMLDivElement | null;
+    getFactory(): (node: TabNode) => React.ReactNode;
+    isRealtimeResize(): boolean;
+    setEditingTab(tabNode?: TabNode): void;
+    getEditingTab(): TabNode | undefined;
+    getModel(): Model;
+    getTabDragSpeed(): number;
+    onCloseLayout: (layout: ModelLayout) => void;
+    onSetWindow: (layout: ModelLayout, window: Window) => void;
+    getScreenRect(inRect: Rect): Rect;
+    getRelativeRect(inRect: Rect): Rect;
+    moveWindowToFront(layoutId: string): void;
+    addTabToTabSet(tabsetId: string, json: IJsonTabNode): TabNode | undefined;
+    addTabToActiveTabSet(json: IJsonTabNode): TabNode | undefined;
+    showControlInPortal: (control: React.ReactNode, element: HTMLElement) => void;
+    hideControlInPortal: () => void;
+    maximize(tabsetNode: TabSetNode): void;
+    customizeTab(tabNode: TabNode, renderValues: ITabRenderValues): void;
+    customizeTabSet(tabSetNode: TabSetNode | BorderNode, renderValues: ITabSetRenderValues): void;
+    i18nName(id: I18nLabel, param?: string): string;
+    getShowOverflowMenu(): import("./LayoutTypes").ShowOverflowMenuCallback | undefined;
+    getTabSetPlaceHolderCallback(): import("./LayoutTypes").TabSetPlaceHolderCallback | undefined;
+    showContextMenu(node: TabNode | TabSetNode | BorderNode, event: React.MouseEvent<HTMLElement, MouseEvent>): void;
+    auxMouseClick(node: TabNode | TabSetNode | BorderNode, event: React.MouseEvent<HTMLElement, MouseEvent>): void;
+    showOverlay(show: boolean): void;
+    showOverlayOnAllWindows(show: boolean): void;
+}
+/** @internal */
+export declare const edgeRectLength = 100;
+/** @internal */
+export declare const edgeRectWidth = 10;

package/types/view/layout/LayoutTypes.d.ts

@@ -0,0 +1,51 @@
+import * as React from "react";
+import { BorderNode } from "../../model/BorderNode";
+import { IJsonTabNode } from "../../model/IJsonModel";
+import { Node } from "../../model/Node";
+import { TabNode } from "../../model/TabNode";
+import { TabSetNode } from "../../model/TabSetNode";
+export type DragRectRenderCallback = (content: React.ReactNode | undefined, node?: Node, json?: IJsonTabNode) => React.ReactNode | undefined;
+export type NodeMouseEvent = (node: TabNode | TabSetNode | BorderNode, event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+export type ShowOverflowMenuCallback = (node: TabSetNode | BorderNode, mouseEvent: React.MouseEvent<HTMLElement, MouseEvent>, items: {
+    index: number;
+    node: TabNode;
+}[], onSelect: (item: {
+    index: number;
+    node: TabNode;
+}) => void) => void;
+export type TabSetPlaceHolderCallback = (node: TabSetNode) => React.ReactNode;
+export interface ITabSetRenderValues {
+    /** a component to be placed before the tabs */
+    leading: React.ReactNode;
+    /** components that will be added after the tabs */
+    stickyButtons: React.ReactNode[];
+    /** components that will be added at the end of the tabset */
+    buttons: React.ReactNode[];
+    /** position to insert overflow button within [...stickyButtons, ...buttons]
+     * if left undefined position will be after the sticky buttons (if any)
+     */
+    overflowPosition: number | undefined;
+}
+export interface ITabRenderValues {
+    /** the icon or other leading component */
+    leading: React.ReactNode;
+    /** the main tab text/component */
+    content: React.ReactNode;
+    /** a set of react components to add to the tab after the content */
+    buttons: React.ReactNode[];
+}
+export interface IIcons {
+    close?: (React.ReactNode | ((tabNode: TabNode) => React.ReactNode));
+    closeTabset?: (React.ReactNode | ((tabSetNode: TabSetNode) => React.ReactNode));
+    popout?: (React.ReactNode | ((tabNode: TabNode) => React.ReactNode));
+    popoutFloat?: (React.ReactNode | ((tabNode: TabNode) => React.ReactNode));
+    maximize?: (React.ReactNode | ((tabSetNode: TabSetNode) => React.ReactNode));
+    restore?: (React.ReactNode | ((tabSetNode: TabSetNode) => React.ReactNode));
+    more?: (React.ReactNode | ((tabSetNode: (TabSetNode | BorderNode), hiddenTabs: {
+        node: TabNode;
+        index: number;
+    }[]) => React.ReactNode));
+    edgeArrow?: React.ReactNode;
+    activeTabset?: (React.ReactNode | ((tabSetNode: TabSetNode) => React.ReactNode));
+    closeFloatPopout?: (React.ReactNode | (() => React.ReactNode));
+}

package/types/Attribute.d.ts

@@ -1,25 +0,0 @@
-/** @internal */
-export declare class Attribute {
-    static NUMBER: string;
-    static STRING: string;
-    static BOOLEAN: string;
-    name: string;
-    alias: string | undefined;
-    modelName?: string;
-    pairedAttr?: Attribute;
-    pairedType?: string;
-    defaultValue: any;
-    alwaysWriteJson?: boolean;
-    type?: string;
-    required: boolean;
-    fixed: boolean;
-    description?: string;
-    constructor(name: string, modelName: string | undefined, defaultValue: any, alwaysWriteJson?: boolean);
-    setType(value: string): this;
-    setAlias(value: string): this;
-    setDescription(value: string): void;
-    setRequired(): this;
-    setFixed(): this;
-    setpairedAttr(value: Attribute): void;
-    setPairedType(value: string): void;
-}

package/types/AttributeDefinitions.d.ts

@@ -1,18 +0,0 @@
-import { Attribute } from "./Attribute";
-/** @internal */
-export declare class AttributeDefinitions {
-    attributes: Attribute[];
-    nameToAttribute: Map<string, Attribute>;
-    constructor();
-    addWithAll(name: string, modelName: string | undefined, defaultValue: any, alwaysWriteJson?: boolean): Attribute;
-    addInherited(name: string, modelName: string): Attribute;
-    add(name: string, defaultValue: any, alwaysWriteJson?: boolean): Attribute;
-    getAttributes(): Attribute[];
-    getModelName(name: string): string | undefined;
-    toJson(jsonObj: any, obj: any): void;
-    fromJson(jsonObj: any, obj: any): void;
-    update(jsonObj: any, obj: any): void;
-    setDefaults(obj: any): void;
-    pairAttributes(type: string, childAttributes: AttributeDefinitions): void;
-    toTypescriptInterface(name: string, parentAttributes: AttributeDefinitions | undefined): string;
-}

package/types/model/Action.d.ts

@@ -1,5 +0,0 @@
-export declare class Action {
-    type: string;
-    data: Record<string, any>;
-    constructor(type: string, data: Record<string, any>);
-}

package/types/model/LayoutWindow.d.ts

@@ -1,44 +0,0 @@
-import { Rect } from "../Rect";
-import { IJsonPopout } from "./IJsonModel";
-import { Model } from "./Model";
-import { RowNode } from "./RowNode";
-import { Node } from "./Node";
-import { TabSetNode } from "./TabSetNode";
-import { LayoutInternal } from "../view/Layout";
-export declare class LayoutWindow {
-    private _windowId;
-    private _layout;
-    private _rect;
-    private _window?;
-    private _root?;
-    private _maximizedTabSet?;
-    private _activeTabSet?;
-    private _toScreenRectFunction;
-    constructor(windowId: string, rect: Rect);
-    visitNodes(fn: (node: Node, level: number) => void): void;
-    get windowId(): string;
-    get rect(): Rect;
-    get layout(): LayoutInternal | undefined;
-    get window(): Window | undefined;
-    get root(): RowNode | undefined;
-    get maximizedTabSet(): TabSetNode | undefined;
-    get activeTabSet(): TabSetNode | undefined;
-    /** @internal */
-    set rect(value: Rect);
-    /** @internal */
-    set layout(value: LayoutInternal);
-    /** @internal */
-    set window(value: Window | undefined);
-    /** @internal */
-    set root(value: RowNode | undefined);
-    /** @internal */
-    set maximizedTabSet(value: TabSetNode | undefined);
-    /** @internal */
-    set activeTabSet(value: TabSetNode | undefined);
-    /** @internal */
-    get toScreenRectFunction(): (rect: Rect) => Rect;
-    /** @internal */
-    set toScreenRectFunction(value: (rect: Rect) => Rect);
-    toJson(): IJsonPopout;
-    static fromJson(windowJson: IJsonPopout, model: Model, windowId: string): LayoutWindow;
-}

package/types/view/SizeTracker.d.ts

@@ -1,13 +0,0 @@
-import * as React from "react";
-import { Rect } from "../Rect";
-import { LayoutInternal } from "./Layout";
-import { TabNode } from "../model/TabNode";
-export interface ISizeTrackerProps {
-    layout: LayoutInternal;
-    node: TabNode;
-    rect: Rect;
-    visible: boolean;
-    forceRevision: number;
-    tabsRevision: number;
-}
-export declare const SizeTracker: React.MemoExoticComponent<({ layout, node }: ISizeTrackerProps) => import("react/jsx-runtime").JSX.Element>;