flexlayout-react 0.8.12 → 0.8.14

package/declarations/model/TabSetNode.d.ts

@@ -1,9 +1,35 @@
+import { AttributeDefinitions } from "../AttributeDefinitions";
+import { DockLocation } from "../DockLocation";
+import { DropInfo } from "../DropInfo";
+import { Orientation } from "../Orientation";
+import { Rect } from "../Rect";
 import { IDraggable } from "./IDraggable";
 import { IDropTarget } from "./IDropTarget";
 import { IJsonTabSetNode } from "./IJsonModel";
+import { LayoutWindow } from "./LayoutWindow";
+import { Model } from "./Model";
 import { Node } from "./Node";
+import { TabNode } from "./TabNode";
 export declare class TabSetNode extends Node implements IDraggable, IDropTarget {
     static readonly TYPE = "tabset";
+    /** @internal */
+    static fromJson(json: any, model: Model, layoutWindow: LayoutWindow): TabSetNode;
+    /** @internal */
+    private static attributeDefinitions;
+    /** @internal */
+    private tabStripRect;
+    /** @internal */
+    private contentRect;
+    /** @internal */
+    private calculatedMinHeight;
+    /** @internal */
+    private calculatedMinWidth;
+    /** @internal */
+    private calculatedMaxHeight;
+    /** @internal */
+    private calculatedMaxWidth;
+    /** @internal */
+    constructor(model: Model, json: any);
     getName(): string | undefined;
     isEnableActiveIcon(): boolean;
     getSelected(): number;
@@ -13,10 +39,14 @@ export declare class TabSetNode extends Node implements IDraggable, IDropTarget
     getAttrMinHeight(): number;
     getMinWidth(): number;
     getMinHeight(): number;
+    /** @internal */
+    getMinSize(orientation: Orientation): number;
     getAttrMaxWidth(): number;
     getAttrMaxHeight(): number;
     getMaxWidth(): number;
     getMaxHeight(): number;
+    /** @internal */
+    getMaxSize(orientation: Orientation): number;
     /**
      * Returns the config attribute that can be used to store node specific data that
      * WILL be saved to the json. The config attribute should be changed via the action Actions.updateNodeAttributes rather
@@ -41,5 +71,35 @@ export declare class TabSetNode extends Node implements IDraggable, IDropTarget
     getClassNameTabStrip(): string | undefined;
     getTabLocation(): string;
     toJson(): IJsonTabSetNode;
+    /** @internal */
+    calcMinMaxSize(): void;
+    /** @internal */
+    canMaximize(): boolean;
+    /** @internal */
+    setContentRect(rect: Rect): void;
+    /** @internal */
+    getContentRect(): Rect;
+    /** @internal */
+    setTabStripRect(rect: Rect): void;
+    /** @internal */
+    setWeight(weight: number): void;
+    /** @internal */
+    setSelected(index: number): void;
     getWindowId(): string;
+    /** @internal */
+    canDrop(dragNode: Node & IDraggable, x: number, y: number): DropInfo | undefined;
+    /** @internal */
+    delete(): void;
+    /** @internal */
+    remove(node: TabNode): void;
+    /** @internal */
+    drop(dragNode: Node, location: DockLocation, index: number, select?: boolean): void;
+    /** @internal */
+    updateAttrs(json: any): void;
+    /** @internal */
+    getAttributeDefinitions(): AttributeDefinitions;
+    /** @internal */
+    static getAttributeDefinitions(): AttributeDefinitions;
+    /** @internal */
+    private static createAttributeDefinitions;
 }

package/declarations/model/Utils.d.ts

@@ -1 +1,9 @@
+import { TabSetNode } from "./TabSetNode";
+import { BorderNode } from "./BorderNode";
+import { RowNode } from "./RowNode";
+import { TabNode } from "./TabNode";
+/** @internal */
+export declare function adjustSelectedIndexAfterDock(node: TabNode): void;
+/** @internal */
+export declare function adjustSelectedIndex(parent: TabSetNode | BorderNode | RowNode, removedIndex: number): void;
 export declare function randomUUID(): string;

package/declarations/view/BorderButton.d.ts

@@ -1 +1,13 @@
-export {};
+import { TabNode } from "../model/TabNode";
+import { IIcons, LayoutInternal } from "./Layout";
+/** @internal */
+export interface IBorderButtonProps {
+    layout: LayoutInternal;
+    node: TabNode;
+    selected: boolean;
+    border: string;
+    icons: IIcons;
+    path: string;
+}
+/** @internal */
+export declare const BorderButton: (props: IBorderButtonProps) => import("react/jsx-runtime").JSX.Element;

package/declarations/view/BorderTab.d.ts

@@ -1 +1,9 @@
+import { LayoutInternal } from "./Layout";
+import { BorderNode } from "../model/BorderNode";
+/** @internal */
+export interface IBorderTabProps {
+    layout: LayoutInternal;
+    border: BorderNode;
+    show: boolean;
+}
 export declare function BorderTab(props: IBorderTabProps): import("react/jsx-runtime").JSX.Element;

package/declarations/view/BorderTabSet.d.ts

@@ -1 +1,10 @@
-export {};
+import { BorderNode } from "../model/BorderNode";
+import { LayoutInternal } from "./Layout";
+/** @internal */
+export interface IBorderTabSetProps {
+    border: BorderNode;
+    layout: LayoutInternal;
+    size: number;
+}
+/** @internal */
+export declare const BorderTabSet: (props: IBorderTabSetProps) => import("react/jsx-runtime").JSX.Element;

package/declarations/view/DragContainer.d.ts

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

package/declarations/view/ErrorBoundary.d.ts

@@ -1 +1,22 @@
-export {};
+import * as React from "react";
+import { ErrorInfo } from "react";
+/** @internal */
+export interface IErrorBoundaryProps {
+    message: string;
+    retryText: string;
+    children: React.ReactNode;
+}
+/** @internal */
+export interface IErrorBoundaryState {
+    hasError: boolean;
+}
+/** @internal */
+export declare class ErrorBoundary extends React.Component<IErrorBoundaryProps, IErrorBoundaryState> {
+    constructor(props: IErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): {
+        hasError: boolean;
+    };
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    retry: () => void;
+    render(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+}

package/declarations/view/Icons.d.ts

@@ -5,3 +5,4 @@ export declare const EdgeIcon: () => import("react/jsx-runtime").JSX.Element;
 export declare const PopoutIcon: () => import("react/jsx-runtime").JSX.Element;
 export declare const RestoreIcon: () => import("react/jsx-runtime").JSX.Element;
 export declare const AsterickIcon: () => import("react/jsx-runtime").JSX.Element;
+export declare const AddIcon: () => import("react/jsx-runtime").JSX.Element;

package/declarations/view/Layout.d.ts

@@ -1,12 +1,16 @@
 import * as React from "react";
+import { DockLocation } from "../DockLocation";
 import { I18nLabel } from "../I18nLabel";
+import { Rect } from "../Rect";
 import { Action } from "../model/Action";
 import { BorderNode } from "../model/BorderNode";
+import { IDraggable } from "../model/IDraggable";
 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 { LayoutWindow } from "../model/LayoutWindow";
 export interface ILayoutProps {
     /** the model for this layout */
     model: Model;
@@ -56,6 +60,12 @@ export interface ILayoutProps {
  * A React component that hosts a multi-tabbed layout
  */
 export declare class Layout extends React.Component<ILayoutProps> {
+    /** @internal */
+    private selfRef;
+    /** @internal */
+    private revision;
+    /** @internal */
+    constructor(props: ILayoutProps);
     /** re-render the layout */
     redraw(): void;
     /**
@@ -97,8 +107,126 @@ export declare class Layout extends React.Component<ILayoutProps> {
     setDragComponent(event: DragEvent, component: React.ReactNode, x: number, y: number): void;
     /** Get the root div element of the layout */
     getRootDiv(): HTMLDivElement | null;
+    /** @internal */
+    render(): import("react/jsx-runtime").JSX.Element;
 }
-export declare const FlexLayoutVersion = "0.8.12";
+/** @internal */
+interface ILayoutInternalProps extends ILayoutProps {
+    renderRevision: number;
+    windowId?: string;
+    mainLayout?: LayoutInternal;
+}
+/** @internal */
+interface ILayoutInternalState {
+    rect: Rect;
+    editingTab?: TabNode;
+    portal?: React.ReactPortal;
+    showEdges: boolean;
+    showOverlay: boolean;
+    calculatedBorderBarSize: number;
+    layoutRevision: number;
+    forceRevision: number;
+    showHiddenBorder: DockLocation;
+}
+/** @internal */
+export declare class LayoutInternal extends React.Component<ILayoutInternalProps, ILayoutInternalState> {
+    static dragState: DragState | undefined;
+    private selfRef;
+    private moveablesRef;
+    private findBorderBarSizeRef;
+    private mainRef;
+    private previousModel?;
+    private orderedTabIds;
+    private orderedTabMoveableIds;
+    private moveableElementMap;
+    private dropInfo;
+    private outlineDiv?;
+    private currentDocument?;
+    private currentWindow?;
+    private supportsPopout;
+    private popoutURL;
+    private icons;
+    private resizeObserver?;
+    private dragEnterCount;
+    private dragging;
+    private windowId;
+    private layoutWindow;
+    private mainLayout;
+    private isMainWindow;
+    private isDraggingOverWindow;
+    private styleObserver;
+    private popoutWindowName;
+    constructor(props: ILayoutInternalProps);
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+    renderBorders(inner: React.ReactNode): import("react/jsx-runtime").JSX.Element;
+    renderLayout(): import("react/jsx-runtime").JSX.Element;
+    renderEdgeIndicators(): React.ReactNode[];
+    renderWindows(): React.ReactNode[];
+    renderTabMoveables(): Map<string, React.ReactNode>;
+    renderTabStamps(): React.ReactNode[];
+    renderTabs(): Map<string, React.ReactNode>;
+    renderMetricsElements(): import("react/jsx-runtime").JSX.Element;
+    checkForBorderToShow(x: number, y: number): void;
+    updateLayoutMetrics: () => void;
+    tidyMoveablesMap(): void;
+    reorderComponents(components: Map<string, React.ReactNode>, ids: string[]): React.ReactNode[];
+    onModelChange: (action: Action) => void;
+    redraw(type?: string): void;
+    redrawInternal(type: string): void;
+    doAction(action: Action): Node | undefined;
+    updateRect: () => void;
+    getBoundingClientRect(div: HTMLElement): Rect;
+    getMoveableContainer(): HTMLDivElement | null;
+    getMoveableElement(id: string): HTMLElement;
+    getMainLayout(): LayoutInternal;
+    getClassName: (defaultClassName: string) => string;
+    getCurrentDocument(): Document | undefined;
+    getDomRect(): Rect;
+    getWindowId(): string;
+    getRootDiv(): HTMLDivElement | null;
+    getMainElement(): HTMLDivElement | null;
+    getFactory(): (node: TabNode) => React.ReactNode;
+    isSupportsPopout(): boolean;
+    isRealtimeResize(): boolean;
+    getPopoutURL(): string;
+    setEditingTab(tabNode?: TabNode): void;
+    getEditingTab(): TabNode | undefined;
+    getModel(): Model;
+    onCloseWindow: (windowLayout: LayoutWindow) => void;
+    onSetWindow: (windowLayout: LayoutWindow, window: Window) => void;
+    getScreenRect(inRect: Rect): Rect;
+    addTabToTabSet(tabsetId: string, json: IJsonTabNode): TabNode | undefined;
+    addTabToActiveTabSet(json: IJsonTabNode): TabNode | undefined;
+    showControlInPortal: (control: React.ReactNode, element: HTMLElement) => void;
+    hideControlInPortal: () => void;
+    getIcons: () => IIcons;
+    maximize(tabsetNode: TabSetNode): void;
+    customizeTab(tabNode: TabNode, renderValues: ITabRenderValues): void;
+    customizeTabSet(tabSetNode: TabSetNode | BorderNode, renderValues: ITabSetRenderValues): void;
+    i18nName(id: I18nLabel, param?: string): string;
+    getShowOverflowMenu(): ShowOverflowMenuCallback | undefined;
+    getTabSetPlaceHolderCallback(): 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;
+    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;
+    setDraggingOverWindow(overWindow: boolean): void;
+    onDragEnterRaw: (event: React.DragEvent<HTMLElement>) => void;
+    onDragLeaveRaw: (event: React.DragEvent<HTMLElement>) => void;
+    clearDragMain(): void;
+    clearDragLocal(): 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;
+}
+export declare const FlexLayoutVersion = "0.8.14";
 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: {
@@ -140,3 +268,17 @@ export interface IIcons {
     edgeArrow?: React.ReactNode;
     activeTabset?: (React.ReactNode | ((tabSetNode: TabSetNode) => React.ReactNode));
 }
+declare enum DragSource {
+    Internal = "internal",
+    External = "external",
+    Add = "add"
+}
+declare class DragState {
+    readonly mainLayout: LayoutInternal;
+    readonly dragSource: DragSource;
+    readonly dragNode: Node & IDraggable | undefined;
+    readonly dragJson: IJsonTabNode | undefined;
+    readonly fnNewNodeDropped: ((node?: Node, event?: React.DragEvent<HTMLElement>) => void) | undefined;
+    constructor(mainLayout: LayoutInternal, dragSource: DragSource, dragNode: Node & IDraggable | undefined, dragJson: IJsonTabNode | undefined, fnNewNodeDropped: ((node?: Node, event?: React.DragEvent<HTMLElement>) => void) | undefined);
+}
+export {};

package/declarations/view/Overlay.d.ts

@@ -1 +1,8 @@
-export {};
+import { LayoutInternal } from "./Layout";
+/** @internal */
+export interface IOverlayProps {
+    layout: LayoutInternal;
+    show: boolean;
+}
+/** @internal */
+export declare const Overlay: (props: IOverlayProps) => import("react/jsx-runtime").JSX.Element;

package/declarations/view/PopoutWindow.d.ts

@@ -1 +1,14 @@
-export {};
+import * as React from "react";
+import { LayoutInternal } from "./Layout";
+import { LayoutWindow } from "../model/LayoutWindow";
+/** @internal */
+export interface IPopoutWindowProps {
+    title: string;
+    layout: LayoutInternal;
+    layoutWindow: LayoutWindow;
+    url: string;
+    onCloseWindow: (layoutWindow: LayoutWindow) => void;
+    onSetWindow: (layoutWindow: LayoutWindow, window: Window) => void;
+}
+/** @internal */
+export declare const PopoutWindow: (props: React.PropsWithChildren<IPopoutWindowProps>) => React.ReactPortal | null;

package/declarations/view/PopupMenu.d.ts

@@ -1 +1,12 @@
-export {};
+import { TabNode } from "../model/TabNode";
+import { LayoutInternal } from "./Layout";
+import { TabSetNode } from "../model/TabSetNode";
+import { BorderNode } from "../model/BorderNode";
+/** @internal */
+export declare function showPopup(triggerElement: Element, parentNode: TabSetNode | BorderNode, items: {
+    index: number;
+    node: TabNode;
+}[], onSelect: (item: {
+    index: number;
+    node: TabNode;
+}) => void, layout: LayoutInternal): void;

package/declarations/view/Row.d.ts

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

package/declarations/view/Splitter.d.ts

@@ -1 +1,14 @@
-export {};
+import { BorderNode } from "../model/BorderNode";
+import { RowNode } from "../model/RowNode";
+import { LayoutInternal } from "./Layout";
+/** @internal */
+export interface ISplitterProps {
+    layout: LayoutInternal;
+    node: RowNode | BorderNode;
+    index: number;
+    horizontal: boolean;
+}
+/** @internal */
+export declare let splitterDragging: boolean;
+/** @internal */
+export declare const Splitter: (props: ISplitterProps) => import("react/jsx-runtime").JSX.Element;

package/declarations/view/Tab.d.ts

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

package/declarations/view/TabButton.d.ts

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

package/declarations/view/TabButtonStamp.d.ts

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

package/declarations/view/TabOverflowHook.d.ts

@@ -1 +1,16 @@
-export {};
+import * as React from "react";
+import { TabSetNode } from "../model/TabSetNode";
+import { BorderNode } from "../model/BorderNode";
+import { Orientation } from "../Orientation";
+import { LayoutInternal } from "./Layout";
+/** @internal */
+export declare const useTabOverflow: (layout: LayoutInternal, 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;
+    onScrollPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+    hiddenTabs: number[];
+    onMouseWheel: (event: React.WheelEvent<HTMLElement>) => void;
+    isDockStickyButtons: boolean;
+    isShowHiddenTabs: boolean;
+};

package/declarations/view/TabSet.d.ts

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

package/declarations/view/Utils.d.ts

@@ -1,5 +1,18 @@
 import * as React from "react";
 import { Node } from "../model/Node";
+import { TabNode } from "../model/TabNode";
+import { LayoutInternal } from "./Layout";
+/** @internal */
+export declare function isDesktop(): boolean;
+/** @internal */
+export declare function getRenderStateEx(layout: LayoutInternal, node: TabNode, iconAngle?: number): {
+    leading: import("react/jsx-runtime").JSX.Element | undefined;
+    content: string | Iterable<React.ReactNode>;
+    name: string;
+    buttons: any[];
+};
+/** @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 function startDrag(doc: Document, event: React.PointerEvent<HTMLElement>, drag: (x: number, y: number) => void, dragEnd: () => void, dragCancel: () => void): void;