@archbase/layout 3.0.0 → 3.0.2

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.2",
   "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.2",
+    "@archbase/data": "3.0.2",
     "@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": {