@archbase/layout 3.0.0 → 3.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Edson Martins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# @archbase/layout
+
+Layout components for Archbase React.
+
+## Installation
+
+```bash
+npm install @archbase/layout
+# or
+pnpm add @archbase/layout
+# or
+yarn add @archbase/layout
+```
+
+## Features
+
+- **Split Pane**: Resizable split panes
+- **Dock Layout**: Advanced dock layout system using Dockview
+- **Responsive Layout**: Mobile-friendly layout components
+- **Sidebar Components**: Collapsible sidebar components
+- **Header/Footer**: Reusable header and footer components
+
+## Dependencies
+
+```json
+{
+  "@mantine/core": "8.3.12",
+  "@mantine/hooks": "8.3.12",
+  "@tabler/icons-react": "^3.27.0",
+  "react": ">=18.0.0",
+  "react-dom": ">=18.0.0"
+}
+```
+
+## Usage
+
+```typescript
+import { 
+  SplitPane, 
+  DockLayout,
+  ArchbaseLayout 
+} from '@archbase/layout';
+```
+
+## License
+
+MIT © Edson Martins
+
+## Documentation
+
+For full documentation, visit [https://react.archbase.dev](https://react.archbase.dev)

package/dist/ArchbaseCard.d.ts

@@ -0,0 +1,2 @@
+export { Card as ArchbaseCard } from '@mantine/core';
+export type { CardProps as ArchbaseCardProps } from '@mantine/core';

package/dist/ArchbaseContainer.d.ts

@@ -0,0 +1,2 @@
+export { Container as ArchbaseContainer } from '@mantine/core';
+export type { ContainerProps as ArchbaseContainerProps } from '@mantine/core';

package/dist/ArchbaseGroup.d.ts

@@ -0,0 +1,2 @@
+export { Group as ArchbaseGroup } from '@mantine/core';
+export type { GroupProps as ArchbaseGroupProps } from '@mantine/core';

package/dist/ArchbaseStack.d.ts

@@ -0,0 +1,2 @@
+export { Stack as ArchbaseStack } from '@mantine/core';
+export type { StackProps as ArchbaseStackProps } from '@mantine/core';

package/dist/barrel-exports.d.ts

@@ -0,0 +1,12 @@
+export { ArchbaseSpaceCentered } from './spaces/components/ArchbaseSpaceCentered';
+export { ArchbaseSpaceCenteredVertically } from './spaces/components/ArchbaseSpaceCenteredVertically';
+export { ArchbaseSpaceCustom } from './spaces/components/ArchbaseSpaceCustom';
+export { ArchbaseSpaceFill } from './spaces/components/ArchbaseSpaceFill';
+export { ArchbaseSpaceFixed } from './spaces/components/ArchbaseSpaceFixed';
+export { ArchbaseSpaceLayer } from './spaces/components/ArchbaseSpaceLayer';
+export { ArchbaseSpacePositioned } from './spaces/components/ArchbaseSpacePositioned';
+export { ArchbaseSpaceInfo } from './spaces/components/ArchbaseSpaceInfo';
+export { ArchbaseSpaceViewPort } from './spaces/components/ArchbaseSpaceViewPort';
+export { ArchbaseSpaceOptions } from './spaces/components/ArchbaseSpaceOptions';
+export { ArchbaseSpaceTop, ArchbaseSpaceBottom, ArchbaseSpaceLeft, ArchbaseSpaceRight, ArchbaseSpaceTopResizable, ArchbaseSpaceBottomResizable, ArchbaseSpaceLeftResizable, ArchbaseSpaceRightResizable } from './spaces/components/ArchbaseSpaceAnchored';
+export { ArchbaseForm } from './containers/form/ArchbaseForm';

package/dist/containers/ArchbaseDockableContainer.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+export interface ArchbaseDockableContainerProps {
+    children?: ReactNode;
+    title: string;
+    reducedTitle: string;
+    containerWidth?: string;
+    backgroundColor?: string;
+    hiddenBackgroundColor?: string;
+    withBorder?: boolean;
+    hiddenWidth?: string;
+    position?: 'left' | 'right';
+    onShow?: () => void;
+    onHide?: () => void;
+    defaultIsDocked?: boolean;
+    defaultIsVisible?: boolean;
+}
+export declare const ArchbaseDockableContainer: ({ children, title, reducedTitle, containerWidth, backgroundColor, hiddenBackgroundColor, withBorder, hiddenWidth, position, onShow, onHide, defaultIsDocked, defaultIsVisible, }: ArchbaseDockableContainerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/containers/advancedtabs/ArchbaseAdvancedTabs.d.ts

@@ -0,0 +1,47 @@
+import { default as React, CSSProperties, ReactNode } from 'react';
+export interface ArchbaseAdvancedTabItem {
+    key: any;
+    favicon: ReactNode | string | undefined;
+    title: string;
+    customTitle?: string;
+}
+export interface ArchbaseAdvancedTabProps {
+    favicon: ReactNode | string | undefined;
+    title: string;
+    /** Título customizado que aparecerá na aba. Pode ser utilizado $title para interpolar o valor na string do customTitle */
+    customTitle?: string;
+    activeTab: boolean;
+    position: number;
+    contentWidth: number;
+    onClick: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onClose: (event: React.MouseEvent<HTMLDivElement>) => void;
+    setDragging: Function;
+    tabsContentWidth: number;
+    animateTabMove: Function;
+    isDragging: boolean;
+    id: any;
+    index: number;
+    sorting: boolean;
+    showButtonClose: boolean;
+    onCloseAllTabs?: () => void;
+    onCloseLeftTabs?: (tabId: string) => void;
+    onCloseRightTabs?: (tabId: string) => void;
+    onCloseOtherTabs?: (tabId: string) => void;
+    totalTabs?: number;
+}
+export interface ArchbaseAdvancedTabsProps {
+    currentTabs: ArchbaseAdvancedTabItem[];
+    buttonCloseOnlyActiveTab: boolean;
+    activeTab: any;
+    onTabChange: Function;
+    onTabClose: Function;
+    className?: string;
+    style?: CSSProperties;
+    dark: boolean;
+    onClick: Function;
+    onCloseAllTabs?: () => void;
+    onCloseLeftTabs?: (tabId: string) => void;
+    onCloseRightTabs?: (tabId: string) => void;
+    onCloseOtherTabs?: (tabId: string) => void;
+}
+export declare const ArchbaseAdvancedTabs: React.FC<ArchbaseAdvancedTabsProps>;

package/dist/containers/advancedtabs/index.d.ts

@@ -0,0 +1,2 @@
+export { ArchbaseAdvancedTabs } from './ArchbaseAdvancedTabs';
+export type { ArchbaseAdvancedTabItem, ArchbaseAdvancedTabProps, ArchbaseAdvancedTabsProps } from './ArchbaseAdvancedTabs';

package/dist/containers/form/ArchbaseForm.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface ArchbaseFormProps {
+    children: React.ReactNode;
+}
+export declare function ArchbaseForm({ children }: ArchbaseFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/containers/form/index.d.ts

@@ -0,0 +1 @@
+export { ArchbaseForm } from './ArchbaseForm';

package/dist/containers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './form';
+export * from '../spaces';
+export * from './advancedtabs';
+export * from './window';
+export * from './split-pane';
+export { ArchbaseDockableContainer } from './ArchbaseDockableContainer';
+export type { ArchbaseDockableContainerProps } from './ArchbaseDockableContainer';

package/dist/containers/split-pane/ArchbaseSplitPane.d.ts

@@ -0,0 +1,124 @@
+import { default as React, ReactNode } from 'react';
+export interface ArchbaseSplitPaneProps {
+    children: ReactNode;
+    /**
+     * Direção do split
+     * @default 'row'
+     */
+    direction?: 'row' | 'column';
+    /**
+     * Tamanho do separador em pixels
+     * @default 4
+     */
+    splitterSize?: number | string;
+    /**
+     * Cor do separador
+     */
+    splitterColor?: string;
+    /**
+     * Cor do separador em hover
+     */
+    splitterHoverColor?: string;
+    /**
+     * Raio da barra divisória
+     */
+    splitterRadius?: number | string;
+    /**
+     * Exibe knob na barra divisória
+     */
+    withKnob?: boolean;
+    /**
+     * Opacidade da barra divisória
+     */
+    opacity?: number | string;
+    /**
+     * Estilo adicional do container
+     */
+    style?: React.CSSProperties;
+    /**
+     * ClassName adicional
+     */
+    className?: string;
+}
+export interface ArchbaseSplitPanePaneProps {
+    children: ReactNode;
+    /**
+     * Tamanho mínimo do painel em pixels
+     */
+    minSize?: number | string;
+    /**
+     * Tamanho máximo do painel em pixels
+     */
+    maxSize?: number | string;
+    /**
+     * Tamanho padrão do painel em pixels ou porcentagem
+     */
+    defaultSize?: number | string;
+    /**
+     * Estilo adicional do painel
+     */
+    style?: React.CSSProperties;
+    /**
+     * ClassName adicional
+     */
+    className?: string;
+}
+export interface ArchbaseSplitPaneResizerProps {
+    /**
+     * Estilo adicional do resizer
+     */
+    style?: React.CSSProperties;
+    /**
+     * ClassName adicional
+     */
+    className?: string;
+}
+/**
+ * Componente ArchbaseSplitPane
+ *
+ * Wrapper sobre @gfazioli/mantine-split-pane para criar layouts redimensionáveis
+ * com painéis divisórios. Ideal para master-detail views, painéis laterais,
+ * editores com preview, etc.
+ *
+ * @example
+ * ```tsx
+ * <ArchbaseSplitPane direction="row">
+ *   <ArchbaseSplitPanePane>
+ *     <FilterPanel />
+ *   </ArchbaseSplitPanePane>
+ *   <ArchbaseSplitPaneResizer />
+ *   <ArchbaseSplitPanePane>
+ *     <ArchbaseDataGrid />
+ *   </ArchbaseSplitPanePane>
+ * </ArchbaseSplitPane>
+ * ```
+ */
+export declare const ArchbaseSplitPane: ({ children, direction, splitterSize, splitterColor, splitterHoverColor, splitterRadius, withKnob, opacity, style, className, }: ArchbaseSplitPaneProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente ArchbaseSplitPanePane
+ *
+ * Representa um painel individual dentro do ArchbaseSplitPane.
+ * Deve ser usado como filho direto de ArchbaseSplitPane.
+ *
+ * @example
+ * ```tsx
+ * <ArchbaseSplitPanePane minSize={200} maxSize={600}>
+ *   <Content />
+ * </ArchbaseSplitPanePane>
+ * ```
+ */
+export declare const ArchbaseSplitPanePane: ({ children, minSize, maxSize, defaultSize, style, className, }: ArchbaseSplitPanePaneProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Componente ArchbaseSplitPaneResizer
+ *
+ * Barra divisória arrastável entre painéis.
+ * Deve ser usado entre ArchbaseSplitPanePane components.
+ *
+ * @example
+ * ```tsx
+ * <ArchbaseSplitPanePane>...</ArchbaseSplitPanePane>
+ * <ArchbaseSplitPaneResizer />
+ * <ArchbaseSplitPanePane>...</ArchbaseSplitPanePane>
+ * ```
+ */
+export declare const ArchbaseSplitPaneResizer: ({ style, className, }: ArchbaseSplitPaneResizerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/containers/split-pane/index.d.ts

@@ -0,0 +1,2 @@
+export { ArchbaseSplitPane, ArchbaseSplitPanePane, ArchbaseSplitPaneResizer } from './ArchbaseSplitPane';
+export type { ArchbaseSplitPaneProps, ArchbaseSplitPanePaneProps, ArchbaseSplitPaneResizerProps } from './ArchbaseSplitPane';

package/dist/containers/window/ArchbaseFloatingWindow.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+export interface ArchbaseFloatingWindowProps {
+    id: string;
+    children?: any;
+    height: number;
+    width: number;
+    top?: number;
+    left?: number;
+    resizable?: boolean;
+    titleBar?: {
+        icon?: string | HTMLImageElement;
+        title?: string;
+        buttons?: {
+            minimize?: boolean;
+            maximize?: boolean;
+            close?: () => void;
+        };
+    };
+    style?: React.CSSProperties;
+    /** Referência para o container que envolve o componente filho */
+    innerRef?: React.RefObject<HTMLInputElement> | undefined;
+}
+export declare const ArchbaseFloatingWindow: React.FC<ArchbaseFloatingWindowProps>;

package/dist/containers/window/index.d.ts

@@ -0,0 +1,2 @@
+export { ArchbaseFloatingWindow, } from './ArchbaseFloatingWindow';
+export type { ArchbaseFloatingWindowProps } from './ArchbaseFloatingWindow';

package/dist/dock/ArchbaseDockLayout.d.ts

@@ -0,0 +1,2 @@
+import { ArchbaseDockLayoutProps } from './ArchbaseDockLayout.types';
+export declare function ArchbaseDockLayout({ components, defaultLayout, watermark, hideBorders, autoHideHeaders, onLayoutChange, onPanelClose, onPanelOpen, style, className, height, disabled, }: ArchbaseDockLayoutProps): import("react/jsx-runtime").JSX.Element;

package/dist/dock/ArchbaseDockLayout.types.d.ts

@@ -0,0 +1,50 @@
+import { CSSProperties, ReactNode } from 'react';
+export type DockComponentType = 'panel' | 'gridview' | 'splitview' | 'dockview';
+export interface DockPanelComponent {
+    id: string;
+    title: string;
+    component: React.ComponentType<any>;
+    tabComponent?: React.ComponentType<any>;
+    params?: Record<string, any>;
+    minimumSize?: number;
+    maximumSize?: number;
+    isClosable?: boolean;
+}
+export interface DockLayoutConfig {
+    direction?: 'horizontal' | 'vertical';
+    defaultSize?: number[];
+    minimumSize?: number[];
+    maximumSize?: number[];
+    proportions?: number[];
+}
+export interface ArchbaseDockLayoutProps {
+    components: Record<string, DockPanelComponent>;
+    defaultLayout?: string | object;
+    watermark?: string | ReactNode;
+    hideBorders?: boolean;
+    autoHideHeaders?: boolean;
+    onLayoutChange?: (layout: object) => void;
+    onPanelClose?: (panelId: string) => void;
+    onPanelOpen?: (panelId: string) => void;
+    style?: CSSProperties;
+    className?: string;
+    height?: string | number;
+    disabled?: boolean;
+}
+export interface DockPanelProps {
+    componentId: string;
+    params?: Record<string, any>;
+    onClose?: () => void;
+    style?: CSSProperties;
+    className?: string;
+}
+export type DockLayoutPreset = 'dashboard' | 'ide' | 'explorer' | 'analytics' | 'custom';
+export interface ArchbaseDockLayoutPresetProps {
+    preset: DockLayoutPreset;
+    components?: Record<string, DockPanelComponent>;
+    onPanelClose?: (panelId: string) => void;
+    onPanelOpen?: (panelId: string) => void;
+    style?: CSSProperties;
+    className?: string;
+    height?: string | number;
+}

package/dist/dock/ArchbaseDockLayoutPreset.d.ts

@@ -0,0 +1,5 @@
+import { ArchbaseDockLayoutPresetProps } from './ArchbaseDockLayout.types';
+/**
+ * Preset de layouts para casos de uso comuns
+ */
+export declare function ArchbaseDockLayoutPreset({ preset, components: userComponents, onPanelClose, onPanelOpen, style, className, height, }: ArchbaseDockLayoutPresetProps): import("react/jsx-runtime").JSX.Element;

package/dist/dock/index.d.ts

@@ -0,0 +1,3 @@
+export { ArchbaseDockLayout } from './ArchbaseDockLayout';
+export { ArchbaseDockLayoutPreset } from './ArchbaseDockLayoutPreset';
+export type { ArchbaseDockLayoutProps, DockPanelComponent, DockLayoutConfig, DockPanelProps, ArchbaseDockLayoutPresetProps, DockLayoutPreset, DockComponentType, } from './ArchbaseDockLayout.types';

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ArchbaseCard';
+export * from './ArchbaseContainer';
+export * from './ArchbaseGroup';
+export * from './ArchbaseStack';
+export * from './containers';
+export * from './dock';
+export * from './spaces';

package/dist/index.js

@@ -1039,7 +1039,7 @@ const ri = ({ children: t, ...i }) => /* @__PURE__ */ c(Vt.Provider, { value: i,
     onCloseRightTabs: S,
     onCloseOtherTabs: w,
     totalTabs: I
-  } = t, { t: B } = Ht(), [P, x] = V(0), [T, _] = V(!1), [k, N] = V(null), [q, D] = V(null), [ot, L] = V(!1), [F, tt] = V(0), [nt, U] = V(!1), lt = it(null), $ = 9, E = 84, H = 60, W = 48;
+  } = t, { t: B } = Ht("archbase"), [P, x] = V(0), [T, _] = V(!1), [k, N] = V(null), [q, D] = V(null), [ot, L] = V(!1), [F, tt] = V(0), [nt, U] = V(!1), lt = it(null), $ = 9, E = 84, H = 60, W = 48;
   et(() => (document.addEventListener("mousemove", j), document.addEventListener("mouseup", O), () => {
     document.removeEventListener("mousemove", j), document.addEventListener("mouseup", O);
   })), et(() => {

package/dist/spaces/components/ArchbaseSpace.d.ts

@@ -0,0 +1,6 @@
+import { IArchbaseSpaceInnerProps } from '../core-react';
+import * as React from 'react';
+export declare class ArchbaseSpace extends React.Component<IArchbaseSpaceInnerProps> {
+    _react_spaces_uniqueid?: string;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/dist/spaces/components/ArchbaseSpaceAnchored.d.ts

@@ -0,0 +1,88 @@
+import { IArchbaseSpaceCommonProps, IResizeHandleProps } from '../core-react';
+import { ResizeHandlePlacement, SizeUnit } from '../core-types';
+import * as PropTypes from 'prop-types';
+import * as React from 'react';
+export interface IArchbaseResizableProps extends IArchbaseSpaceCommonProps {
+    size: SizeUnit;
+    order?: number;
+    handleSize?: number;
+    touchHandleSize?: number;
+    handlePlacement?: ResizeHandlePlacement;
+    handleRender?: (handleProps: IResizeHandleProps) => React.ReactNode;
+    minimumSize?: number;
+    maximumSize?: number;
+    onResizeStart?: () => void | boolean;
+    onResizeEnd?: (newSize: SizeUnit) => void;
+}
+export declare const resizableProps: {
+    size: PropTypes.Validator<NonNullable<NonNullable<string | number>>>;
+    order: PropTypes.Requireable<number>;
+    handleSize: PropTypes.Requireable<number>;
+    touchHandleSize: PropTypes.Requireable<number>;
+    handlePlacement: PropTypes.Requireable<ResizeHandlePlacement>;
+    handleRender: PropTypes.Requireable<(...args: any[]) => any>;
+    minimumSize: PropTypes.Requireable<number>;
+    maximumSize: PropTypes.Requireable<number>;
+    onResizeStart: PropTypes.Requireable<(...args: any[]) => any>;
+    onResizeEnd: PropTypes.Requireable<(...args: any[]) => any>;
+    id: PropTypes.Requireable<string>;
+    className: PropTypes.Requireable<string>;
+    style: PropTypes.Requireable<object>;
+    as: PropTypes.Requireable<any>;
+    centerContent: PropTypes.Requireable<import('..').CenterType>;
+    zIndex: PropTypes.Requireable<number>;
+    scrollable: PropTypes.Requireable<boolean>;
+    trackSize: PropTypes.Requireable<boolean>;
+    allowOverflow: PropTypes.Requireable<boolean>;
+    onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    onDoubleClick: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseDown: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseMove: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchStart: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchMove: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchEnd: PropTypes.Requireable<(...args: any[]) => any>;
+};
+export interface IArchbaseAnchorProps extends IArchbaseResizableProps {
+    resizable?: boolean;
+}
+export declare const anchoredProps: {
+    resizable: PropTypes.Requireable<boolean>;
+    size: PropTypes.Validator<NonNullable<NonNullable<string | number>>>;
+    order: PropTypes.Requireable<number>;
+    handleSize: PropTypes.Requireable<number>;
+    touchHandleSize: PropTypes.Requireable<number>;
+    handlePlacement: PropTypes.Requireable<ResizeHandlePlacement>;
+    handleRender: PropTypes.Requireable<(...args: any[]) => any>;
+    minimumSize: PropTypes.Requireable<number>;
+    maximumSize: PropTypes.Requireable<number>;
+    onResizeStart: PropTypes.Requireable<(...args: any[]) => any>;
+    onResizeEnd: PropTypes.Requireable<(...args: any[]) => any>;
+    id: PropTypes.Requireable<string>;
+    className: PropTypes.Requireable<string>;
+    style: PropTypes.Requireable<object>;
+    as: PropTypes.Requireable<any>;
+    centerContent: PropTypes.Requireable<import('..').CenterType>;
+    zIndex: PropTypes.Requireable<number>;
+    scrollable: PropTypes.Requireable<boolean>;
+    trackSize: PropTypes.Requireable<boolean>;
+    allowOverflow: PropTypes.Requireable<boolean>;
+    onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    onDoubleClick: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseDown: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseMove: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchStart: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchMove: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchEnd: PropTypes.Requireable<(...args: any[]) => any>;
+};
+export declare const ArchbaseSpaceLeftResizable: React.FC<IArchbaseResizableProps>;
+export declare const ArchbaseSpaceLeft: React.FC<IArchbaseAnchorProps>;
+export declare const ArchbaseSpaceTopResizable: React.FC<IArchbaseResizableProps>;
+export declare const ArchbaseSpaceTop: React.FC<IArchbaseAnchorProps>;
+export declare const ArchbaseSpaceRightResizable: React.FC<IArchbaseResizableProps>;
+export declare const ArchbaseSpaceRight: React.FC<IArchbaseAnchorProps>;
+export declare const ArchbaseSpaceBottomResizable: React.FC<IArchbaseResizableProps>;
+export declare const ArchbaseSpaceBottom: React.FC<IArchbaseAnchorProps>;

package/dist/spaces/components/ArchbaseSpaceCentered.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+interface IProps {
+    children?: React.ReactNode;
+}
+export declare const ArchbaseSpaceCentered: React.FC<IProps>;
+export {};

package/dist/spaces/components/ArchbaseSpaceCenteredVertically.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+interface IProps {
+    children?: React.ReactNode;
+}
+export declare const ArchbaseSpaceCenteredVertically: React.FC<IProps>;
+export {};

package/dist/spaces/components/ArchbaseSpaceCustom.d.ts

@@ -0,0 +1,18 @@
+import { Type, SizeUnit, AnchorType, ResizeType } from '../core-types';
+import { IArchbaseSpaceCommonProps } from '../core-react';
+import { IArchbaseAnchorProps } from './ArchbaseSpaceAnchored';
+import * as React from "react";
+type IArchbaseSpaceCustomProps = Omit<IArchbaseSpaceCommonProps & IArchbaseAnchorProps, "size"> & {
+    type?: Type;
+    anchor?: AnchorType;
+    anchorSize?: SizeUnit;
+    left?: SizeUnit | undefined;
+    top?: SizeUnit | undefined;
+    right?: SizeUnit | undefined;
+    bottom?: SizeUnit | undefined;
+    width?: SizeUnit | undefined;
+    height?: SizeUnit | undefined;
+    resizeTypes?: ResizeType[];
+};
+export declare const ArchbaseSpaceCustom: React.FC<IArchbaseSpaceCustomProps>;
+export {};

package/dist/spaces/components/ArchbaseSpaceFill.d.ts

@@ -0,0 +1,3 @@
+import { IArchbaseSpaceCommonProps } from '../core-react';
+import * as React from "react";
+export declare const ArchbaseSpaceFill: React.FC<IArchbaseSpaceCommonProps>;

package/dist/spaces/components/ArchbaseSpaceFixed.d.ts

@@ -0,0 +1,9 @@
+import { SizeUnit } from '../core-types';
+import { IArchbaseSpaceCommonProps } from '../core-react';
+import * as React from "react";
+interface IArchbaseSpaceFixedProps extends IArchbaseSpaceCommonProps {
+    width?: SizeUnit;
+    height: SizeUnit;
+}
+export declare const ArchbaseSpaceFixed: React.FC<IArchbaseSpaceFixedProps>;
+export {};

package/dist/spaces/components/ArchbaseSpaceInfo.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+interface IArchbaseSpaceSpaceInfoProps {
+    children: (info: DOMRect) => React.ReactElement;
+}
+/**
+ * @deprecated use useCurrentSpace() hook instead
+ */
+export declare const ArchbaseSpaceInfo: React.FC<IArchbaseSpaceSpaceInfoProps>;
+export {};

package/dist/spaces/components/ArchbaseSpaceLayer.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface IProps {
+    zIndex: number;
+    children?: React.ReactNode;
+}
+export declare const ArchbaseSpaceLayer: React.FC<IProps>;
+export {};

package/dist/spaces/components/ArchbaseSpaceOptions.d.ts

@@ -0,0 +1,7 @@
+import { IArchbaseSpacesOptions } from '../core-react';
+import * as React from "react";
+interface IProps extends IArchbaseSpacesOptions {
+    children?: React.ReactNode;
+}
+export declare const ArchbaseSpaceOptions: React.FC<IProps>;
+export {};

package/dist/spaces/components/ArchbaseSpacePositioned.d.ts

@@ -0,0 +1,16 @@
+import { SizeUnit, ResizeType } from '../core-types';
+import { IArchbaseSpaceCommonProps } from '../core-react';
+import * as React from "react";
+interface IArchbaseSpacePositionedProps extends IArchbaseSpaceCommonProps {
+    left?: SizeUnit;
+    top?: SizeUnit;
+    right?: SizeUnit;
+    bottom?: SizeUnit;
+    width?: SizeUnit;
+    height?: SizeUnit;
+    resizable?: ResizeType[];
+    onResizeStart?: () => void | boolean;
+    onResizeEnd?: (newSize: SizeUnit) => void;
+}
+export declare const ArchbaseSpacePositioned: React.FC<IArchbaseSpacePositionedProps>;
+export {};

package/dist/spaces/components/ArchbaseSpaceViewPort.d.ts

@@ -0,0 +1,11 @@
+import { SizeUnit } from '../core-types';
+import { IArchbaseSpaceCommonProps } from '../core-react';
+import * as React from "react";
+interface IArchbaseSpaceViewPortProps extends IArchbaseSpaceCommonProps {
+    left?: SizeUnit;
+    right?: SizeUnit;
+    top?: SizeUnit;
+    bottom?: SizeUnit;
+}
+export declare const ArchbaseSpaceViewPort: React.FC<IArchbaseSpaceViewPortProps>;
+export {};

package/dist/spaces/components/index.d.ts

@@ -0,0 +1,11 @@
+export * from './ArchbaseSpaceAnchored';
+export * from './ArchbaseSpaceCentered';
+export * from './ArchbaseSpaceCenteredVertically';
+export * from './ArchbaseSpaceCustom';
+export * from './ArchbaseSpaceFill';
+export * from './ArchbaseSpaceFixed';
+export * from './ArchbaseSpaceLayer';
+export * from './ArchbaseSpacePositioned';
+export * from './ArchbaseSpaceInfo';
+export * from './ArchbaseSpaceViewPort';
+export * from './ArchbaseSpaceOptions';

package/dist/spaces/core-dragging.d.ts

@@ -0,0 +1,8 @@
+import { SyntheticEvent } from 'react';
+import { ISpaceDefinition, ISpaceStore, EndEvent, MoveEvent, OnDragEnd } from './core-types';
+export declare function createDrag(store: ISpaceStore): {
+    startDrag<T extends SyntheticEvent<HTMLElement> | MouseEvent | TouchEvent>(e: T, space: ISpaceDefinition, endEvent: EndEvent, moveEvent: MoveEvent, getCoords: (event: T) => {
+        x: number;
+        y: number;
+    }, onDragEnd?: OnDragEnd): void;
+};

package/dist/spaces/core-react.d.ts

@@ -0,0 +1,78 @@
+import { ISpaceProps, ISpaceStore, ISpaceDefinition, CenterType, ISpaceContext, ICommonProps } from './core-types';
+import * as React from "react";
+import * as PropTypes from "prop-types";
+export declare const useEffectOnce: (effect: () => void | (() => void)) => void;
+export declare const ParentContext: React.Context<string>;
+export declare const DOMRectContext: React.Context<DOMRect>;
+export declare const LayerContext: React.Context<number>;
+export declare const OptionsContext: React.Context<IArchbaseSpacesOptions>;
+export declare const currentStore: ISpaceStore;
+export declare const commonProps: {
+    id: PropTypes.Requireable<string>;
+    className: PropTypes.Requireable<string>;
+    style: PropTypes.Requireable<object>;
+    as: PropTypes.Requireable<any>;
+    centerContent: PropTypes.Requireable<CenterType>;
+    zIndex: PropTypes.Requireable<number>;
+    scrollable: PropTypes.Requireable<boolean>;
+    trackSize: PropTypes.Requireable<boolean>;
+    allowOverflow: PropTypes.Requireable<boolean>;
+    handleRender: PropTypes.Requireable<(...args: any[]) => any>;
+    onClick: PropTypes.Requireable<(...args: any[]) => any>;
+    onDoubleClick: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseDown: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
+    onMouseMove: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchStart: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchMove: PropTypes.Requireable<(...args: any[]) => any>;
+    onTouchEnd: PropTypes.Requireable<(...args: any[]) => any>;
+};
+export interface IArchbaseSpacesOptions {
+    debug?: boolean;
+}
+export interface IReactEvents {
+    onClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    onDoubleClick?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    onMouseDown?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    onMouseLeave?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    onMouseMove?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    onTouchStart?: (event: React.TouchEvent<HTMLElement>) => void;
+    onTouchMove?: (event: React.TouchEvent<HTMLElement>) => void;
+    onTouchEnd?: (event: React.TouchEvent<HTMLElement>) => void;
+}
+export interface IArchbaseSpaceCommonProps extends ICommonProps, IReactEvents {
+    style?: React.CSSProperties;
+    as?: keyof HTMLElementTagNameMap | React.ComponentType<ICommonProps>;
+    children?: React.ReactNode;
+}
+export interface IArchbaseSpaceInnerProps extends IArchbaseSpaceCommonProps, ISpaceProps, IReactEvents {
+    handleRender?: (handleProps: IResizeHandleProps) => React.ReactNode;
+}
+export interface IArchbaseSpacesOptions {
+    debug?: boolean;
+}
+export declare function useForceUpdate(): () => void;
+export declare function useUniqueId(): string;
+export declare function useSpace(props: IArchbaseSpaceInnerProps): {
+    space: ISpaceDefinition;
+    resizeHandles: {
+        mouseHandles: IResizeHandleProps[];
+    };
+    domRect: DOMRect;
+    elementRef: React.RefObject<HTMLElement>;
+};
+export interface IResizeHandleProps {
+    id?: string;
+    key: string | number;
+    className?: string;
+    onMouseDown: (e: React.MouseEvent<HTMLElement, MouseEvent>) => void;
+    onTouchStart: (e: React.TouchEvent<HTMLElement>) => void;
+}
+export declare function useSpaceResizeHandles(store: ISpaceStore, space: ISpaceDefinition): {
+    mouseHandles: IResizeHandleProps[];
+};
+export declare function useArchbaseCurrentSpace(): ISpaceContext;
+export declare let SSR_SUPPORT_ENABLED: boolean;
+export declare function enabledSsrSupport(): void;

package/dist/spaces/core-resizing.d.ts

@@ -0,0 +1,12 @@
+import { SyntheticEvent } from 'react';
+import { ISpaceDefinition, ResizeType, ISpaceStore, OnResizeEnd, EndEvent, MoveEvent } from './core-types';
+export interface IResizeChange {
+    x: number;
+    y: number;
+}
+export declare function createResize(store: ISpaceStore): {
+    startResize<T extends SyntheticEvent<HTMLElement> | MouseEvent | TouchEvent>(e: T, resizeType: ResizeType, space: ISpaceDefinition, endEvent: EndEvent, moveEvent: MoveEvent, getCoords: (event: T) => {
+        x: number;
+        y: number;
+    }, onResizeEnd?: OnResizeEnd): void;
+};

package/dist/spaces/core-types.d.ts

@@ -0,0 +1,167 @@
+export type ResizeMouseEvent = React.MouseEvent<HTMLElement, MouseEvent>;
+export type ResizeTouchEvent = React.TouchEvent<HTMLElement>;
+export type OnResizeStart = ((resizeType?: ResizeType) => void | boolean) | undefined;
+export type OnResizeEnd = ((newSize: SizeUnit, domRect: DOMRect, resizeType?: ResizeType) => void) | undefined;
+export type OnDragEnd = (position: IPosition, moved: boolean) => void;
+export declare enum Type {
+    ViewPort = "viewport",
+    Fixed = "fixed",
+    Fill = "fill",
+    Positioned = "positioned",
+    Anchored = "anchored",
+    Custom = "custom"
+}
+export declare enum AnchorType {
+    Left = "anchor-left",
+    Right = "anchor-right",
+    Top = "anchor-top",
+    Bottom = "anchor-bottom"
+}
+export declare enum Orientation {
+    Horizontal = 0,
+    Vertical = 1
+}
+export type SizeUnit = number | string | undefined;
+export declare enum ResizeType {
+    All = "resize-all",
+    Left = "resize-left",
+    Right = "resize-right",
+    Top = "resize-top",
+    Bottom = "resize-bottom",
+    TopLeft = "resize-topleft",
+    TopRight = "resize-topright",
+    BottomLeft = "resize-bottomleft",
+    BottomRight = "resize-bottomright"
+}
+export declare enum ResizeHandlePlacement {
+    OverlayInside = "overlay-inside",
+    Inside = "inside",
+    OverlayBoundary = "overlay-boundary"
+}
+export declare enum CenterType {
+    None = "none",
+    Vertical = "vertical",
+    HorizontalVertical = "horizontalVertical"
+}
+export declare enum MoveEvent {
+    Mouse = "mousemove",
+    Touch = "touchmove"
+}
+export declare enum EndEvent {
+    Mouse = "mouseup",
+    Touch = "touchend"
+}
+export interface ICommonProps {
+    id?: string;
+    className?: string;
+    centerContent?: CenterType;
+    zIndex?: number;
+    scrollable?: boolean;
+    trackSize?: boolean;
+    allowOverflow?: boolean;
+}
+export interface ISpaceProps extends ICommonProps {
+    type: Type;
+    anchor?: AnchorType | undefined;
+    order?: number | undefined;
+    position?: IPositionalProps | undefined;
+    handleSize?: number | undefined;
+    handlePlacement?: ResizeHandlePlacement;
+    touchHandleSize?: number | undefined;
+    minimumSize?: number | undefined;
+    maximumSize?: number | undefined;
+    onResizeStart?: OnResizeStart;
+    onResizeEnd?: OnResizeEnd;
+}
+export interface ISpaceStore {
+    getSpaces: () => ISpaceDefinition[];
+    getSpace: (id: string) => ISpaceDefinition | undefined;
+    addSpace: (space: ISpaceDefinition) => void;
+    updateSpace: (space: ISpaceDefinition, props: ISpaceProps) => void;
+    updateStyles: (space: ISpaceDefinition) => void;
+    removeSpace: (space: ISpaceDefinition) => void;
+    createSpace: (parent: string | undefined, props: ISpaceProps, update: () => void) => ISpaceDefinition;
+    startMouseResize: (resizeType: ResizeType, space: ISpaceDefinition, event: React.MouseEvent<HTMLElement>, onResizeEnd?: OnResizeEnd) => void;
+    startTouchResize: (resizeType: ResizeType, space: ISpaceDefinition, event: React.TouchEvent<HTMLElement>, onResizeEnd?: OnResizeEnd) => void;
+    startMouseDrag: (space: ISpaceDefinition, event: ResizeMouseEvent, onDragEnd?: OnDragEnd) => void;
+    startTouchDrag: (space: ISpaceDefinition, event: ResizeTouchEvent, onDragEnd?: OnDragEnd) => void;
+}
+export interface IPosition {
+    left?: SizeUnit | undefined;
+    top?: SizeUnit | undefined;
+    right?: SizeUnit | undefined;
+    bottom?: SizeUnit | undefined;
+    width?: SizeUnit | undefined;
+    height?: SizeUnit | undefined;
+}
+export interface IPositionalProps extends IPosition {
+    leftResizable?: boolean;
+    topResizable?: boolean;
+    rightResizable?: boolean;
+    bottomResizable?: boolean;
+    topLeftResizable?: boolean;
+    topRightResizable?: boolean;
+    bottomLeftResizable?: boolean;
+    bottomRightResizable?: boolean;
+}
+export interface ISize {
+    size: SizeUnit;
+    adjusted: SizeUnit[];
+    resized: number;
+}
+export interface ISpaceDefinition {
+    update: () => void;
+    updateParent: () => void;
+    adjustLeft: (adjusted: SizeUnit[]) => boolean;
+    adjustRight: (adjusted: SizeUnit[]) => boolean;
+    adjustTop: (adjusted: SizeUnit[]) => boolean;
+    adjustBottom: (adjusted: SizeUnit[]) => boolean;
+    adjustEdge: (adjusted: SizeUnit[]) => boolean;
+    anchoredChildren: (children: ISpaceDefinition[], anchor: AnchorType, zIndex: number) => ISpaceDefinition[];
+    onResizeStart?: OnResizeStart;
+    onResizeEnd?: OnResizeEnd;
+    element: HTMLElement;
+    id: string;
+    type: Type;
+    anchor?: AnchorType;
+    orientation: Orientation;
+    scrollable: boolean;
+    order?: number;
+    position: "fixed" | "absolute" | "relative";
+    children: ISpaceDefinition[];
+    parentId: string | undefined;
+    store: ISpaceStore;
+    left: ISize;
+    top: ISize;
+    right: ISize;
+    bottom: ISize;
+    width: ISize;
+    height: ISize;
+    zIndex: number;
+    dimension: DOMRect;
+    centerContent: "none" | "vertical" | "horizontalVertical";
+    resizing: boolean;
+    minimumSize?: number;
+    maximumSize?: number;
+    handleSize: number;
+    touchHandleSize: number;
+    handlePlacement: ResizeHandlePlacement;
+    canResizeTop: boolean;
+    canResizeLeft: boolean;
+    canResizeRight: boolean;
+    canResizeBottom: boolean;
+    canResizeTopLeft: boolean;
+    canResizeTopRight: boolean;
+    canResizeBottomLeft: boolean;
+    canResizeBottomRight: boolean;
+    allowOverflow: boolean;
+    ssrStyle: string;
+}
+export interface ISpaceContext {
+    size: DOMRect;
+    layer: number;
+    startMouseDrag: (e: ResizeMouseEvent, onDragEnd?: OnDragEnd) => void;
+    startTouchDrag: (e: ResizeTouchEvent, onDragEnd?: OnDragEnd) => void;
+    forceUpdate: () => void;
+    ssrStyle?: string;
+}

package/dist/spaces/core-utils.d.ts

@@ -0,0 +1,12 @@
+import { ISpaceDefinition, SizeUnit, ISize } from './core-types';
+export declare function omit<K extends string, T extends Record<K, unknown>>(object: T, ...keys: K[]): Omit<T, K>;
+export declare function shortuuid(): string;
+export declare function getSizeString(size: SizeUnit): string;
+export declare function css(size: ISize, dontAddCalc?: boolean): string;
+export declare function coalesce<T>(...args: T[]): T;
+export declare function adjustmentsEqual(item1: SizeUnit[], item2: SizeUnit[]): boolean;
+export declare function throttle<F extends (...args: any) => any>(callback: F, limit: number): (...args: any) => void;
+export declare function styleDefinition(space: ISpaceDefinition): string;
+export declare function updateStyleDefinition(space: ISpaceDefinition): void;
+export declare function removeStyleDefinition(space: ISpaceDefinition): void;
+export declare function isServer(): boolean;

package/dist/spaces/core.d.ts

@@ -0,0 +1,2 @@
+import { ISpaceStore } from './core-types';
+export declare function createStore(): ISpaceStore;

package/dist/spaces/index.d.ts

@@ -0,0 +1,5 @@
+import { ISpaceContext, IPosition, OnResizeStart, OnResizeEnd, OnDragEnd, ResizeMouseEvent, ResizeTouchEvent } from './core-types';
+export * from './components';
+export { ResizeHandlePlacement, ResizeType, AnchorType, CenterType, Type } from './core-types';
+export type { ISpaceContext, IPosition, OnResizeStart, OnResizeEnd, OnDragEnd, ResizeMouseEvent, ResizeTouchEvent };
+export { useArchbaseCurrentSpace, enabledSsrSupport } from './core-react';

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@archbase/layout",
-  "version": "3.0.0",
+  "version": "3.0.3",
   "description": "Layout components for Archbase React",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -25,26 +25,27 @@
   "author": "Edson Martins",
   "license": "MIT",
   "dependencies": {
+    "@archbase/core": "3.0.3",
+    "@archbase/data": "3.0.3",
     "@gfazioli/mantine-split-pane": "^2.5.6",
     "css-element-queries": "^1.2.3",
     "dockview-react": "^4.12.0",
     "i18next": "^25.3.1",
     "lodash": "4.17.21",
     "prop-types": "15.8.1",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
     "react-i18next": "^15.1.2",
-    "usehooks-ts": "^2.16.0",
-    "@archbase/core": "3.0.0",
-    "@archbase/data": "3.0.0"
+    "usehooks-ts": "^2.16.0"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.200",
     "@types/prop-types": "^15.7.12",
-    "@types/react": "^19.0.0",
-    "@types/react-dom": "^19.0.0",
+    "@types/react": "^19.0.6",
+    "@types/react-dom": "^19.0.2",
     "typescript": "^5.7.0",
     "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.4",
     "vitest": "^2.0.0"
   },
   "peerDependencies": {