@cratis/event-models 0.113.0 → 0.114.0

package/README.md

@@ -45,9 +45,11 @@ The board reports when someone selects a slice's screen preview. `@cratis/event-
 Install what the editor draws with. These are optional peers, required only by this entry:
 
 ```bash
-npm install @cratis/scene.model @cratis/scene.engine @cratis/scene.react @cratis/scene.components @cratis/scene.primereact @cratis/scene.tailwind @cratis/scene.blueprint.default @cratis/scene.blueprint.components @primereact/core @primereact/headless primereact lucide-react react-icons chart.js quill
+npm install @cratis/scene.model @cratis/scene.engine @cratis/scene.react @cratis/scene.components @cratis/scene.primereact @cratis/scene.tailwind @cratis/scene.blueprint.default @cratis/scene.blueprint.components @primereact/core @primereact/headless @primereact/styles primereact lucide-react react-icons chart.js quill
 ```
 
+PrimeReact must be 11.2.0 or newer (`@primereact/core`, `@primereact/headless`, `@primereact/styles` and `primereact`): the editor imports component styles that 11.2.0 introduced (`@primereact/styles/inputpassword`), so an earlier 11 fails to resolve the entry. `yarn guard:peer-floor` checks every style specifier against the declared floor.
+
 The Scene packages must be 4.7.0 or newer: that release adds the chart, multi-state checkbox, file upload, data scroller, tree table and rich text editor controls and the JSON property type the editor draws a field for. `chart.js` (4.5.1 or newer) draws the chart control and `quill` (2.0.3 or newer) is the rich text control's engine. Both are optional peers of this entry, and a host that offers those controls in its palette installs them. Quill's stylesheet is part of `@cratis/event-models/screen-editor/styles`, so there is nothing more to import.
 
 Import the editor's stylesheet beside the board's, and Scene's:
@@ -75,7 +77,7 @@ import { ScreenEditorPrimeReactProvider } from '@cratis/event-models/screen-edit
 </CratisComponentsProvider>
 ```
 
-`ScreenEditorPrimeReactProvider` is PrimeReact's own `PrimeReactProvider` under a name this package exports, and it takes the same props (license, theme, locale, pass-through, defaults). It is not a second context: the published bundle imports `@primereact/core/config` from your install, so the provider and every PrimeReact component in the page share one context. Import `PrimeReactProvider` from `@primereact/core/config` yourself if you prefer; the result is identical. Either way, install a single `@primereact/core`.
+`ScreenEditorPrimeReactProvider` is PrimeReact's own `PrimeReactProvider` with one addition, and it takes the same props (license, theme, locale, pass-through, defaults). The addition is the component styles: PrimeReact 11 ships its components as structure with no look, and the look comes from `@primereact/styles`, which a provider has to be handed as `defaults`. Without them a screen drawn in the editor is the right markup with none of the appearance it has in Play - a button that is plain text, a card with no surface, a field with no box. This provider hands them over (`screenEditorPrimeReactDefaults`), and any `defaults` you pass are merged into those component by component and part by part - an entry you give `Button` adds to its styles and never replaces them; where you set the same prop, yours wins. It is not a second context: the published bundle imports `@primereact/core/config` from your install, so the provider and every PrimeReact component in the page share one context. If you use `PrimeReactProvider` from `@primereact/core/config` yourself, pass `defaults={screenEditorPrimeReactDefaults}` to it - and merge your own entries into it with `mergeComponentDefaults`, since a plain object spread replaces a whole component entry, styles included. Either way, install a single `@primereact/core`.
 
 - The editor needs no Studio Core, Arc, router or Studio provider. It does need a PrimeReact provider (`ScreenEditorPrimeReactProvider`), because the default palette offers PrimeReact components and those throw without one. If a component does fail, the editor closes with a message and the page it was opened over carries on.
 - PrimeReact 11 checks a license key at runtime and shows an *Invalid PrimeUI License* badge without one. The key belongs to your application: pass it to the provider. The package never sees it.

package/dist/screen-editor/ScreenEditor/Defaults/defaultComponentIcons.d.ts

@@ -0,0 +1,3 @@
+import type { PackageIcon } from './defaultPackageIcons';
+export declare const defaultComponentIcons: Readonly<Record<string, PackageIcon>>;
+export declare const iconComponentOf: (componentName: string) => PackageIcon;

package/dist/screen-editor/ScreenEditor/Defaults/defaultPackageIcons.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentType } from 'react';
+export type PackageIcon = ComponentType<{
+    'aria-hidden'?: boolean | 'true' | 'false';
+}>;
+export declare const defaultPackageIcons: Readonly<Record<string, PackageIcon>>;
+export declare const unknownPackageIcon: PackageIcon;

package/dist/screen-editor/ScreenEditor/Document/canvasMoveEdits.d.ts

@@ -0,0 +1,4 @@
+import { type SceneEdit, type SceneElement } from '@cratis/scene.model';
+import type { StructureEdit } from '../Structure/StructureEdit';
+import { type CanvasPlacement } from './placeOnCanvas';
+export declare function canvasMoveEdits(roots: readonly SceneElement[], edit: StructureEdit, at?: CanvasPlacement): SceneEdit[] | undefined;

package/dist/screen-editor/ScreenEditor/Document/placeOnCanvas.d.ts

@@ -0,0 +1,10 @@
+import type { SceneElement } from '@cratis/scene.model';
+export interface CanvasPlacement {
+    left: number;
+    top: number;
+}
+export declare const canvasCascadeStep = 32;
+export declare const cascadedPlacement: (siblings: number) => CanvasPlacement;
+export declare function placeOnCanvas<T extends SceneElement>(element: T, placement: CanvasPlacement): T;
+export declare function placementOf(element: SceneElement): CanvasPlacement | undefined;
+export declare function removePlacement<T extends SceneElement>(element: T): T;

package/dist/screen-editor/ScreenEditor/Host/ScreenEditorController.d.ts

@@ -1,3 +1,4 @@
+import type { CanvasPlacement } from '../Document/placeOnCanvas';
 import type { NodeInspection, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement } from '@cratis/scene.model';
 import type { EditingContext } from '@cratis/scene.engine';
 import type { Ownership } from '../Structure/Ownership';
@@ -28,10 +29,12 @@ export interface ScreenEditorController {
         applied: boolean;
         diagnostics: SceneDiagnostic[];
     };
-    move: (edit: StructureEdit) => StructureEditRejection | undefined;
-    insertComponent: (componentName: string, parentId: string | undefined, index: number | undefined) => void;
-    insertLayout: (item: LayoutItem, parentId: string | undefined, index: number | undefined) => void;
+    move: (edit: StructureEdit, at?: CanvasPlacement) => StructureEditRejection | undefined;
+    validateMove: (edit: StructureEdit) => StructureEditRejection | undefined;
+    insertComponent: (componentName: string, parentId: string | undefined, index: number | undefined, at?: CanvasPlacement) => void;
+    insertLayout: (item: LayoutItem, parentId: string | undefined, index: number | undefined, at?: CanvasPlacement) => void;
     remove: (elementId: string) => void;
+    canRemove: (elementId: string) => boolean;
     setProperty: (property: NodeInspection['properties'][number], value: unknown) => void;
     undo: () => void;
     redo: () => void;

package/dist/screen-editor/ScreenEditor/Host/ScreenEditorPrimeReactProvider.d.ts

@@ -1,3 +1,3 @@
 import { PrimeReactProvider } from '@primereact/core/config';
 export type ScreenEditorPrimeReactProviderProps = NonNullable<Parameters<typeof PrimeReactProvider>[0]>;
-export declare const ScreenEditorPrimeReactProvider: (props: ScreenEditorPrimeReactProviderProps) => import("react").JSX.Element;
+export declare const ScreenEditorPrimeReactProvider: ({ defaults, theme, ...props }: ScreenEditorPrimeReactProviderProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Host/mergeComponentDefaults.d.ts

@@ -0,0 +1,3 @@
+type Defaults = Record<string, unknown>;
+export declare function mergeComponentDefaults<T extends Defaults>(editor: T, host: Defaults | undefined): T;
+export {};

package/dist/screen-editor/ScreenEditor/Host/screenEditorPrimeReactDefaults.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentDefaults } from '@primereact/types/core';
+export declare const screenEditorPrimeReactDefaults: ComponentDefaults;

package/dist/screen-editor/ScreenEditor/Inspector/ScreenEditorStrings.d.ts

@@ -4,6 +4,7 @@ import type { JsonPropertyFieldStrings } from '../PropertyEditors/Json/JsonPrope
 import type { Ownership } from '../Structure/Ownership';
 import type { SceneDocumentProblem } from '../Document/readSceneDocument';
 import type { StructureEditRejection } from '../Structure/StructureEditRejection';
+import type { SurfaceStrings } from '../Surface/DesignTime/SurfaceStrings';
 export interface ScreenEditorStrings {
     inspectorTitle: string;
     windowLabel: string;
@@ -32,10 +33,12 @@ export interface ScreenEditorStrings {
         message: string;
         close: string;
     };
+    surface: SurfaceStrings;
     undo: string;
     redo: string;
     palette: string;
     layoutDrawer: string;
+    packageTitles: Record<string, string>;
     closeDrawer: string;
     deleteElement: string;
     saveRefused: string;

package/dist/screen-editor/ScreenEditor/Inspector/StructureTree.d.ts

@@ -9,5 +9,6 @@ export interface StructureTreeProps<T> {
     selectedId?: string;
     onSelect: (id: string) => void;
     onEdit: (edit: StructureEdit) => StructureEditRejection | undefined;
+    onRemove?: (id: string) => void;
 }
-export declare function StructureTree<T>({ roots, adapter, strings, selectedId, onSelect, onEdit }: StructureTreeProps<T>): import("react").JSX.Element;
+export declare function StructureTree<T>({ roots, adapter, strings, selectedId, onSelect, onEdit, onRemove }: StructureTreeProps<T>): import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Palette/PaletteFolders.d.ts

@@ -0,0 +1,7 @@
+import type { PaletteDrawer } from './buildPalette';
+export interface PaletteFoldersProps {
+    drawers: readonly PaletteDrawer[];
+    closeLabel: string;
+    onActivate: (payload: unknown) => void;
+}
+export declare const PaletteFolders: ({ drawers, closeLabel, onActivate }: PaletteFoldersProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Palette/buildPalette.d.ts

@@ -5,6 +5,7 @@ import type { LayoutItem } from '../Layouts/LayoutItem';
 export interface PaletteDrawer {
     id: string;
     title: string;
+    icon: ReactNode;
     items: ToolbarDrawerItem[];
 }
 export interface PaletteSource {
@@ -16,7 +17,7 @@ export interface PaletteIcons {
     component: (componentName: string) => ReactNode;
     drawer: {
         layout: ReactNode;
-        package: ReactNode;
+        package: (packageName: string) => ReactNode;
     };
 }
-export declare function buildPalette(layoutTitle: string, labels: LayoutLabels, icons: PaletteIcons, sources: readonly PaletteSource[]): PaletteDrawer[];
+export declare function buildPalette(layoutTitle: string, labels: LayoutLabels, icons: PaletteIcons, sources: readonly PaletteSource[], packageTitles?: Readonly<Record<string, string>>): PaletteDrawer[];

package/dist/screen-editor/ScreenEditor/Properties/visibleProperties.d.ts

@@ -0,0 +1,2 @@
+import type { InspectedProperty } from '@cratis/scene.model';
+export declare function visibleProperties(properties: InspectedProperty[], inCanvas: boolean, placed: Record<string, unknown> | undefined): InspectedProperty[];

package/dist/screen-editor/ScreenEditor/Runtime/profileColorScheme.d.ts

@@ -0,0 +1,2 @@
+import type { Theme } from '@cratis/scene.model';
+export declare function profileColorSchemeClasses(theme: Pick<Theme, 'isDark'> | undefined): string;

package/dist/screen-editor/ScreenEditor/Runtime/profileTheme.d.ts

@@ -0,0 +1,3 @@
+import type { Theme } from '@cratis/scene.model';
+import type { ScreenEditorRuntime } from './screenEditorRuntime';
+export declare function profileTheme(runtime: Pick<ScreenEditorRuntime, 'bundles' | 'profile'>): Theme | undefined;

package/dist/screen-editor/ScreenEditor/Runtime/withSampleContentProperties.d.ts

@@ -0,0 +1,3 @@
+import { type ComponentDescriptor } from '@cratis/scene.model';
+export declare const contentGroup = "Content";
+export declare function withSampleContentProperties(descriptor: ComponentDescriptor): ComponentDescriptor;

package/dist/screen-editor/ScreenEditor/Selection/sceneTree.d.ts

@@ -2,3 +2,5 @@ import type { SceneElement } from '@cratis/scene.model';
 export declare function childrenOfElement(element: SceneElement): SceneElement[];
 export declare function everyElementId(roots: readonly SceneElement[]): string[];
 export declare function findSceneElement(roots: readonly SceneElement[], id: string): SceneElement | undefined;
+export declare function parentOf(roots: readonly SceneElement[], id: string): SceneElement | undefined;
+export declare function isCanvasHolding(roots: readonly SceneElement[], id: string): boolean;

package/dist/screen-editor/ScreenEditor/Structure/isDeleteKey.d.ts

@@ -0,0 +1,15 @@
+export declare const isTypingTarget: (target: EventTarget | null) => boolean;
+export interface DeleteKeyEvent {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    defaultPrevented: boolean;
+    repeat?: boolean;
+    target: EventTarget | null;
+    nativeEvent?: {
+        isComposing?: boolean;
+    };
+}
+export declare const isDeleteKey: (event: DeleteKeyEvent) => boolean;

package/dist/screen-editor/ScreenEditor/Structure/removal.d.ts

@@ -0,0 +1,3 @@
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function isRemovable<T>(roots: T[], id: string, adapter: StructureTreeAdapter<T>): boolean;
+export declare function selectionAfterRemoval<T>(roots: T[], id: string, adapter: StructureTreeAdapter<T>): string | undefined;

package/dist/screen-editor/ScreenEditor/Structure/surfaceMoveEdit.d.ts

@@ -0,0 +1,3 @@
+import type { StructureEdit } from './StructureEdit';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function surfaceMoveEdit<T>(roots: T[], adapter: StructureTreeAdapter<T>, movedId: string, containerId: string, markerIndex: number): StructureEdit | undefined;

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/DesignTimeComponent.d.ts

@@ -0,0 +1,4 @@
+import { type ComponentType } from 'react';
+import type { RegisteredComponentProps } from '@cratis/scene.react';
+import type { SurfaceStrings } from './SurfaceStrings';
+export declare function designTimeComponent(registryKey: string, Component: ComponentType<RegisteredComponentProps>, strings: SurfaceStrings, message?: ComponentType<RegisteredComponentProps>): ComponentType<RegisteredComponentProps>;

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/DesignTimePlaceholder.d.ts

@@ -0,0 +1,7 @@
+import { DesignTimePlaceholderTone } from './DesignTimePlaceholderTone';
+export interface DesignTimePlaceholderProps {
+    elementId: string;
+    tone: DesignTimePlaceholderTone;
+    text: string;
+}
+export declare const DesignTimePlaceholder: ({ elementId, tone, text }: DesignTimePlaceholderProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/DesignTimePlaceholderTone.d.ts

@@ -0,0 +1,5 @@
+export declare enum DesignTimePlaceholderTone {
+    Empty = "empty",
+    Failed = "failed",
+    Declaration = "declaration"
+}

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/OverlayPreview.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentType, type ReactNode } from 'react';
+import type { ExternalComponent } from '@cratis/scene.model';
+import type { RegisteredComponentProps } from '@cratis/scene.react';
+import { OverlayKind } from './overlayKinds';
+export interface OverlayPreviewProps {
+    kind: OverlayKind;
+    tag: string;
+    element: ExternalComponent;
+    slots: Record<string, ReactNode[]>;
+    message?: ComponentType<RegisteredComponentProps>;
+}
+export declare function OverlayPreview({ kind, tag, element, slots, message }: OverlayPreviewProps): import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/SurfaceStrings.d.ts

@@ -0,0 +1,12 @@
+export interface SurfaceStrings {
+    emptyContainer: string;
+    moveHandle: (name: string) => string;
+    dropTarget: (where: 'into' | 'between') => string;
+    dropDenied: string;
+    nothingToShow: (name: string) => string;
+    declaration: (name: string) => string;
+    sampleContent: (properties: string[]) => string;
+    overlay: (name: string) => string;
+    unavailable: (name: string) => string;
+    failedToDraw: (name: string, reason: string) => string;
+}

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/designTimeRegistry.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentRegistry } from '@cratis/scene.react';
+import type { SurfaceStrings } from './SurfaceStrings';
+export declare function designTimeRegistry(registry: ComponentRegistry, strings: SurfaceStrings): ComponentRegistry;

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/designTimeSamples.d.ts

@@ -0,0 +1,7 @@
+export type SampleProperties = Readonly<Record<string, unknown>>;
+export declare const designTimeSamples: Readonly<Record<string, SampleProperties>>;
+export declare const declarationComponents: ReadonlySet<string>;
+export declare const bareNameOf: (componentName: string) => string;
+export declare const sampleOf: (registryKey: string, componentName: string) => SampleProperties | undefined;
+export declare function withSampleProperties(registryKey: string, componentName: string, properties: Readonly<Record<string, unknown>> | undefined): Record<string, unknown>;
+export declare function sampleKeysInUse(registryKey: string, componentName: string, properties: Readonly<Record<string, unknown>> | undefined): string[];

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/overlayKinds.d.ts

@@ -0,0 +1,8 @@
+export declare enum OverlayKind {
+    Window = "window",
+    Toast = "toast",
+    Tooltip = "tooltip",
+    Mask = "mask",
+    Busy = "busy"
+}
+export declare const overlayKinds: Readonly<Record<string, OverlayKind>>;

package/dist/screen-editor/ScreenEditor/Surface/DesignTime/useRendersVisibleContent.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from 'react';
+export declare const holdsVisibleContent: (probe: Element) => boolean;
+export declare function useRendersVisibleContent(probe: RefObject<HTMLElement | null>, dependency: unknown): boolean;

package/dist/screen-editor/ScreenEditor/Surface/DropIndicator.d.ts

@@ -0,0 +1,6 @@
+import type { DragFeedback } from './useSurfaceDrop';
+export interface DropIndicatorProps {
+    feedback: DragFeedback;
+    deniedText: string;
+}
+export declare const DropIndicator: ({ feedback, deniedText }: DropIndicatorProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Surface/ScreenSurface.d.ts

@@ -2,10 +2,13 @@ import type { BindingResolver } from '@cratis/scene.engine';
 import type { EffectiveConfiguration } from '@cratis/scene.model';
 import type { ScreenEditorController } from '../Host/ScreenEditorController';
 import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { SurfaceStrings } from './DesignTime/SurfaceStrings';
 export interface ScreenSurfaceProps {
     controller: ScreenEditorController;
     environment: ScreenEditorEnvironment;
     resolveBinding: BindingResolver;
     configuration?: EffectiveConfiguration;
+    strings: SurfaceStrings;
+    viewportHeight?: number;
 }
-export declare const ScreenSurface: ({ controller, environment, resolveBinding, configuration }: ScreenSurfaceProps) => import("react").JSX.Element;
+export declare const ScreenSurface: ({ controller, environment, resolveBinding, configuration, strings, viewportHeight }: ScreenSurfaceProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Surface/dragPayload.d.ts

@@ -2,6 +2,11 @@ import type { DragEvent } from 'react';
 import { type PalettePayload } from '../Palette/PaletteEntry';
 export declare const paletteMediaType = "application/x-studio-palette-item";
 export declare const elementMediaType = "application/x-studio-element";
-export declare const setPaletteDrag: (event: DragEvent, payload: PalettePayload) => void;
+export declare function setDragPreview(event: Pick<DragEvent, 'dataTransfer'>, label: string, icon?: Element | null): void;
+export declare const setPaletteDrag: (event: DragEvent, payload: PalettePayload, label?: string) => void;
+export declare const setElementDrag: (event: DragEvent, elementId: string, label: string) => void;
+export declare const readElementDrag: (event: Pick<DragEvent, 'dataTransfer'>) => string | undefined;
+export declare const isElementDrag: (event: Pick<DragEvent, 'dataTransfer'>) => boolean;
+export declare const isSurfaceDrag: (event: Pick<DragEvent, 'dataTransfer'>) => boolean;
 export declare function readPaletteDrag(event: Pick<DragEvent, 'dataTransfer'>): PalettePayload | undefined;
 export declare const isPaletteDrag: (event: Pick<DragEvent, 'dataTransfer'>) => boolean;

package/dist/screen-editor/ScreenEditor/Surface/dropRegionRects.d.ts

@@ -11,4 +11,3 @@ export interface PlacedRegion {
     rect: Rect;
 }
 export declare function placeRegion(region: DropRegion, surface: Rect, rectOf: RectOf): Rect | undefined;
-export declare function regionAt(regions: readonly PlacedRegion[], x: number, y: number, slop?: number): PlacedRegion | undefined;

package/dist/screen-editor/ScreenEditor/Surface/elementRect.d.ts

@@ -0,0 +1,2 @@
+import type { Rect } from './dropRegionRects';
+export declare function elementRect(surface: Element, elementId: string, origin: DOMRect): Rect | undefined;

package/dist/screen-editor/ScreenEditor/Surface/resolveDropTarget.d.ts

@@ -0,0 +1,6 @@
+import type { PlacedRegion, Rect } from './dropRegionRects';
+export interface ResolvedDrop {
+    target: PlacedRegion;
+    container: Rect;
+}
+export declare function resolveDropTarget(regions: readonly PlacedRegion[], x: number, y: number, edge?: number): ResolvedDrop | undefined;

package/dist/screen-editor/ScreenEditor/Surface/useSurfaceDrop.d.ts

@@ -0,0 +1,22 @@
+import { type DragEvent, type RefObject } from 'react';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { PlacedRegion } from './dropRegionRects';
+import { type ResolvedDrop } from './resolveDropTarget';
+export interface DragFeedback {
+    drop?: ResolvedDrop;
+    denied: boolean;
+}
+type Controller = Pick<ScreenEditorController, 'insertComponent' | 'insertLayout' | 'ownershipOf' | 'move' | 'validateMove' | 'composition' | 'adapter'>;
+export declare function useSurfaceDrop(surface: RefObject<HTMLDivElement | null>, measureNow: () => PlacedRegion[], controller: Controller): {
+    feedback: DragFeedback | undefined;
+    draggedId: string | undefined;
+    startMoving: (elementId: string) => void;
+    endMoving: () => void;
+    handlers: {
+        onDragEnter: (event: DragEvent) => void;
+        onDragOver: (event: DragEvent) => void;
+        onDragLeave: (event: DragEvent) => void;
+        onDrop: (event: DragEvent) => void;
+    };
+};
+export {};

package/dist/screen-editor/ScreenEditor/Surface/useSurfaceMeasurement.d.ts

@@ -0,0 +1,9 @@
+import { type RefObject } from 'react';
+import type { DropRegion } from '../DropRegions/DropRegion';
+import { type PlacedRegion, type Rect } from './dropRegionRects';
+export interface SurfaceMeasurement {
+    placed: PlacedRegion[];
+    selectionRect: Rect | undefined;
+    measureNow: () => PlacedRegion[];
+}
+export declare function useSurfaceMeasurement(surface: RefObject<HTMLDivElement | null>, dropRegions: readonly DropRegion[], selectedId: string | undefined): SurfaceMeasurement;

package/dist/screen-editor/ScreenEditor/index.d.ts

@@ -1,5 +1,6 @@
 export * from './Host/ScreenEditorOverlay';
 export * from './Host/ScreenEditorPrimeReactProvider';
+export * from './Host/screenEditorPrimeReactDefaults';
 export * from './Host/ScreenEditorWorkspace';
 export * from './Host/ScreenEditorWindow';
 export * from './Host/ScreenEditorController';