@cratis/event-models 0.113.0 → 0.114.1

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';