@cratis/event-models 0.112.0 → 0.114.0

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonProperties.d.ts

@@ -0,0 +1,9 @@
+import type { InspectedProperty } from '@cratis/scene.model';
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export interface JsonPropertiesProps {
+    properties: readonly InspectedProperty[];
+    componentId: string;
+    setProperty: (property: InspectedProperty, value: unknown) => void;
+    strings?: JsonPropertyFieldStrings;
+}
+export declare const JsonProperties: ({ properties, componentId, setProperty, strings }: JsonPropertiesProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonPropertyField.d.ts

@@ -0,0 +1,13 @@
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export interface JsonPropertyFieldProps {
+    label: string;
+    description?: string;
+    value: unknown;
+    onApply: (value: unknown) => void;
+    readOnly?: boolean;
+    reason?: string;
+    required?: boolean;
+    strings: JsonPropertyFieldStrings;
+    rows?: number;
+}
+export declare const JsonPropertyField: ({ label, description, value, onApply, readOnly, reason, required, strings, rows }: JsonPropertyFieldProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonPropertyFieldStrings.d.ts

@@ -0,0 +1,9 @@
+export interface JsonPropertyFieldStrings {
+    placeholder: string;
+    problems: {
+        required: string;
+        syntax: (detail: string) => string;
+        unsafeInteger: (literal: string) => string;
+        outOfRange: (literal: string) => string;
+    };
+}

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/JsonReading.d.ts

@@ -0,0 +1,8 @@
+import type { JsonProblem } from './JsonProblem';
+export type JsonReading = {
+    value: unknown;
+    problem?: undefined;
+} | {
+    problem: JsonProblem;
+    value?: undefined;
+};

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/defaultJsonPropertyFieldStrings.d.ts

@@ -0,0 +1,2 @@
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export declare const defaultJsonPropertyFieldStrings: JsonPropertyFieldStrings;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/describeJsonProblem.d.ts

@@ -0,0 +1,3 @@
+import type { JsonProblem } from './JsonProblem';
+import type { JsonPropertyFieldStrings } from './JsonPropertyFieldStrings';
+export declare function describeJsonProblem(problem: JsonProblem, strings: JsonPropertyFieldStrings): string;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/formatJson.d.ts

@@ -0,0 +1 @@
+export declare const formatJson: (value: unknown) => string;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/isJsonValueType.d.ts

@@ -0,0 +1,4 @@
+import { PropertyValueType, type InspectedProperty } from '@cratis/scene.model';
+export declare const jsonValueType = PropertyValueType.Json;
+export declare const isJsonValueType: (valueType: string) => boolean;
+export declare const isJsonProperty: (property: InspectedProperty) => boolean;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/jsonDraft.d.ts

@@ -0,0 +1,11 @@
+import type { JsonDraftOutcome } from './JsonDraftOutcome';
+import type { JsonDraftState } from './JsonDraftState';
+export declare const startJsonDraft: (value: unknown) => JsonDraftState;
+export declare const editJsonDraft: (state: JsonDraftState, text: string) => JsonDraftState;
+export declare const syncJsonDraft: (state: JsonDraftState, value: unknown) => JsonDraftState;
+export declare const revertJsonDraft: (state: JsonDraftState) => JsonDraftState;
+export declare function resolveJsonDraft(state: JsonDraftState, required: boolean): JsonDraftOutcome;
+export declare function commitJsonDraft(state: JsonDraftState, required: boolean): {
+    state: JsonDraftState;
+    outcome: JsonDraftOutcome;
+};

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/numberLiteralsOf.d.ts

@@ -0,0 +1 @@
+export declare function numberLiteralsOf(text: string): string[];

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/readJson.d.ts

@@ -0,0 +1,2 @@
+import type { JsonReading } from './JsonReading';
+export declare function readJson(text: string): JsonReading;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/sameJson.d.ts

@@ -0,0 +1 @@
+export declare function sameJson(left: unknown, right: unknown): boolean;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/useJsonDraft.d.ts

@@ -0,0 +1,9 @@
+import type { JsonDraftOutcome } from './JsonDraftOutcome';
+export interface JsonDraft {
+    text: string;
+    outcome: JsonDraftOutcome;
+    edit: (text: string) => void;
+    commit: () => void;
+    revert: () => void;
+}
+export declare function useJsonDraft(value: unknown, required: boolean, onApply: (value: unknown) => void): JsonDraft;

package/dist/screen-editor/ScreenEditor/PrototypeProjection/LegacyExtras.d.ts

@@ -0,0 +1,11 @@
+export interface LegacyExtras {
+    top: Record<string, unknown>;
+    topKeys: string[];
+    canvas: Record<string, unknown>;
+    position: {
+        x: number;
+        y: number;
+    };
+    slots: Record<string, unknown>;
+    emptyName: boolean;
+}

package/dist/screen-editor/ScreenEditor/PrototypeProjection/applyLegacyState.d.ts

@@ -0,0 +1,3 @@
+export declare function applyLegacyState(element: object, top: Record<string, unknown>, zIndex: number): void;
+export declare function appliedState(top: Record<string, unknown>): Record<string, unknown>;
+export declare const stateFields: string[];

package/dist/screen-editor/ScreenEditor/PrototypeProjection/layoutContainerItems.d.ts

@@ -0,0 +1,4 @@
+import { LayoutItem } from '../Layouts/LayoutItem';
+export declare const legacyLayoutLibrary = "StudioLayout";
+export declare function layoutItemOfLegacyType(legacyType: string): LayoutItem | undefined;
+export declare function legacyTypeOfLayoutItem(item: LayoutItem): string;

package/dist/screen-editor/ScreenEditor/PrototypeProjection/legacyPlacement.d.ts

@@ -0,0 +1,5 @@
+export declare const canvasLeft = "Canvas.Left";
+export declare const canvasTop = "Canvas.Top";
+export declare const legacyTypeKey = "legacyType";
+export declare const legacyOriginalKey = "legacy";
+export declare const legacyExtrasKey = "legacyExtras";

package/dist/screen-editor/ScreenEditor/PrototypeProjection/projectToLegacyElements.d.ts

@@ -0,0 +1,3 @@
+import type { Panel } from '@cratis/scene.model';
+export type NativeLegacyType = (componentName: string) => string | undefined;
+export declare function projectToLegacyElements(root: Panel | undefined, nativeType?: NativeLegacyType): unknown[];

package/dist/screen-editor/ScreenEditor/PrototypeProjection/sceneComponentName.d.ts

@@ -0,0 +1,3 @@
+export declare function sceneComponentName(legacyType: string): string;
+export declare function legacyClassName(componentName: string): string;
+export declare function legacyLibrary(legacyType: string): string;

package/dist/screen-editor/ScreenEditor/PrototypeProjection/withoutNulls.d.ts

@@ -0,0 +1 @@
+export declare function withoutNulls<T>(value: T): T;

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/screenEditorRuntime.d.ts

@@ -0,0 +1,17 @@
+import { type DescriptorCatalog, type EffectiveIconCatalog, type PackageCatalog } from '@cratis/scene.engine';
+import type { ComponentDescriptor, UiProfile } from '@cratis/scene.model';
+import { type ComponentRegistry, type IconAdapterRegistry, type ScenePackageBundle } from '@cratis/scene.react';
+export interface ScreenEditorRuntime {
+    id: number;
+    bundles: ScenePackageBundle[];
+    registry: ComponentRegistry;
+    packages: PackageCatalog;
+    descriptors: ComponentDescriptor[];
+    catalog: DescriptorCatalog;
+    profile: UiProfile;
+    icons: EffectiveIconCatalog;
+    iconAdapters: IconAdapterRegistry;
+    isKnownComponent: (bareName: string) => boolean;
+    legacyTypeOf: (componentName: string) => string | undefined;
+}
+export declare function createScreenEditorRuntime(bundles: ScenePackageBundle[], profile: UiProfile): ScreenEditorRuntime;

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

@@ -0,0 +1,4 @@
+import type { ScenePackageBundle } from '@cratis/scene.react';
+import type { PersistedUiProfile } from '../../UiProfile/PersistedUiProfile';
+import { type ScreenEditorRuntime } from './screenEditorRuntime';
+export declare function screenEditorRuntimeForProfile(applied?: PersistedUiProfile, bundles?: ScenePackageBundle[]): ScreenEditorRuntime;

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

@@ -0,0 +1,3 @@
+export declare const unreadablePrototypeTypes: readonly string[];
+export declare const registeredPrototypeTypes: readonly string[];
+export declare const serverPrototypeTypes: ReadonlySet<string>;

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

@@ -0,0 +1,2 @@
+import type { EffectiveIconCatalog } from '@cratis/scene.engine';
+export declare function useLoadedIconCatalog(catalog: EffectiveIconCatalog): number;

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

@@ -0,0 +1,2 @@
+import { type ComponentDescriptor } from '@cratis/scene.model';
+export declare function withActionPresentation(descriptor: ComponentDescriptor): ComponentDescriptor;

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

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

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/panelLayoutItem.d.ts

@@ -0,0 +1,3 @@
+import { type Panel } from '@cratis/scene.model';
+import { LayoutItem } from '../Layouts/LayoutItem';
+export declare function panelLayoutItem(panel: Panel): LayoutItem | undefined;

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

@@ -0,0 +1,4 @@
+import type { SceneElement } from '@cratis/scene.model';
+import type { OwnershipResolver } from '../Structure/OwnershipResolver';
+import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
+export declare function createSceneStructureAdapter(ownershipOf: OwnershipResolver): StructureTreeAdapter<SceneElement>;

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

@@ -0,0 +1,6 @@
+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/Selection/surfaceArrangementOfRoot.d.ts

@@ -0,0 +1,3 @@
+import type { Panel } from '@cratis/scene.model';
+import { LayoutArrangement } from '@cratis/scene/ScreenEditor';
+export declare function surfaceArrangementOfRoot(root: Panel | undefined): LayoutArrangement;

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

@@ -0,0 +1,3 @@
+import { PrototypeLayout } from '@cratis/scene';
+import { type Panel } from '@cratis/scene.model';
+export declare function surfaceLayoutOfRoot(root: Panel | undefined): PrototypeLayout;

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

@@ -0,0 +1,5 @@
+import { type InsertNodeEdit, type MoveNodeEdit, type RemoveNodeEdit, type SceneElement } from '@cratis/scene.model';
+import type { StructureEdit } from '../Structure/StructureEdit';
+export declare function toMoveNodeEdit(edit: StructureEdit): MoveNodeEdit | undefined;
+export declare function toInsertNodeEdit(parentId: string, index: number, element: SceneElement): InsertNodeEdit;
+export declare function toRemoveNodeEdit(elementId: string): RemoveNodeEdit;

package/dist/screen-editor/ScreenEditor/Session/EditSession.d.ts

@@ -0,0 +1,25 @@
+import type { SceneDiagnostic, SceneDocument, SceneEdit } from '@cratis/scene.model';
+import { type EditingContext } from '@cratis/scene.engine';
+interface Step {
+    before: SceneDocument;
+    label: string;
+}
+export interface ScreenEditSession {
+    document: SceneDocument;
+    undoable: readonly Step[];
+    redoable: readonly Step[];
+    diagnostics: SceneDiagnostic[];
+    isDirty: boolean;
+    savedDocument: SceneDocument;
+}
+export declare const maximumHistory = 100;
+export declare function openSession(document: SceneDocument): ScreenEditSession;
+export declare function applyToSession(session: ScreenEditSession, edit: SceneEdit, context: EditingContext, label: string): ScreenEditSession;
+export declare function applyAllToSession(session: ScreenEditSession, edits: SceneEdit[], context: EditingContext, label: string): ScreenEditSession;
+export declare const canUndo: (session: ScreenEditSession) => boolean;
+export declare const canRedo: (session: ScreenEditSession) => boolean;
+export declare function undo(session: ScreenEditSession): ScreenEditSession;
+export declare function redo(session: ScreenEditSession): ScreenEditSession;
+export declare function resetSession(document: SceneDocument): ScreenEditSession;
+export declare function markSaved(session: ScreenEditSession): ScreenEditSession;
+export {};

package/dist/screen-editor/ScreenEditor/Session/SessionCell.d.ts

@@ -0,0 +1,8 @@
+import type { ScreenEditSession } from './EditSession';
+export declare class SessionCell {
+    private latest;
+    private readonly publish;
+    constructor(latest: ScreenEditSession, publish: (session: ScreenEditSession) => void);
+    get current(): ScreenEditSession;
+    commit(change: (current: ScreenEditSession) => ScreenEditSession): ScreenEditSession;
+}

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

@@ -0,0 +1,5 @@
+export declare enum DropZone {
+    Before = "before",
+    Inside = "inside",
+    After = "after"
+}

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

@@ -0,0 +1,6 @@
+export declare enum MoveIntent {
+    MoveUp = "moveUp",
+    MoveDown = "moveDown",
+    Outdent = "outdent",
+    Indent = "indent"
+}

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

@@ -0,0 +1,5 @@
+export declare enum Ownership {
+    Local = "local",
+    Inherited = "inherited",
+    ConfigurableInherited = "configurableInherited"
+}

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

@@ -0,0 +1,2 @@
+import type { Ownership } from './Ownership';
+export type OwnershipResolver = (elementId: string) => Ownership;

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

@@ -0,0 +1,5 @@
+export interface StructureEdit {
+    nodeId: string;
+    targetParentId: string | null;
+    index: number;
+}

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

@@ -0,0 +1,9 @@
+export declare enum StructureEditRejection {
+    NodeNotFound = "nodeNotFound",
+    TargetNotFound = "targetNotFound",
+    TargetNotContainer = "targetNotContainer",
+    WouldCreateCycle = "wouldCreateCycle",
+    NodeLocked = "nodeLocked",
+    TargetLocked = "targetLocked",
+    NoChange = "noChange"
+}

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

@@ -0,0 +1,6 @@
+export interface StructureLocation<T> {
+    node: T;
+    parent: T | null;
+    index: number;
+    siblings: T[];
+}

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

@@ -0,0 +1,9 @@
+export declare enum StructureOperation {
+    Select = "select",
+    Configure = "configure",
+    Move = "move",
+    Resize = "resize",
+    Restyle = "restyle",
+    Insert = "insert",
+    Delete = "delete"
+}

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

@@ -0,0 +1,8 @@
+export interface StructureRow<T> {
+    node: T;
+    id: string;
+    depth: number;
+    parentId: string | null;
+    hasChildren: boolean;
+    isExpanded: boolean;
+}

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

@@ -0,0 +1,11 @@
+import type { LayoutArrangement } from '@cratis/scene/ScreenEditor';
+import type { Ownership } from './Ownership';
+export interface StructureTreeAdapter<T> {
+    idOf(node: T): string;
+    nameOf(node: T): string;
+    childrenOf(node: T): T[];
+    withChildren(node: T, children: T[]): T;
+    acceptsChildren(node: T): boolean;
+    ownershipOf(node: T): Ownership;
+    arrangementOf(node: T): LayoutArrangement | undefined;
+}

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

@@ -0,0 +1,4 @@
+import type { StructureLocation } from './StructureLocation';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function findStructureNode<T>(roots: T[], id: string, adapter: StructureTreeAdapter<T>, parent?: T | null): StructureLocation<T> | undefined;
+export declare function isWithinStructureNode<T>(node: T, id: string, adapter: StructureTreeAdapter<T>): boolean;

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

@@ -0,0 +1,3 @@
+import type { StructureRow } from './StructureRow';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function flattenStructure<T>(roots: T[], expandedIds: ReadonlySet<string>, adapter: StructureTreeAdapter<T>, depth?: number, parentId?: string | null): StructureRow<T>[];

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/isOperationPermitted.d.ts

@@ -0,0 +1,3 @@
+import { Ownership } from './Ownership';
+import { StructureOperation } from './StructureOperation';
+export declare function isOperationPermitted(ownership: Ownership, operation: StructureOperation): 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/resolveMoveIntentEdit.d.ts

@@ -0,0 +1,4 @@
+import { MoveIntent } from './MoveIntent';
+import type { StructureEdit } from './StructureEdit';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function resolveMoveIntentEdit<T>(roots: T[], nodeId: string, intent: MoveIntent, adapter: StructureTreeAdapter<T>): StructureEdit | undefined;

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

@@ -0,0 +1,4 @@
+import { DropZone } from './DropZone';
+import type { StructureEdit } from './StructureEdit';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function resolveTreeDrop<T>(roots: T[], movedId: string, targetId: string, zone: DropZone, adapter: StructureTreeAdapter<T>): StructureEdit | 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/Structure/validateStructureEdit.d.ts

@@ -0,0 +1,4 @@
+import type { StructureEdit } from './StructureEdit';
+import { StructureEditRejection } from './StructureEditRejection';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function validateStructureEdit<T>(roots: T[], edit: StructureEdit, adapter: StructureTreeAdapter<T>): StructureEditRejection | 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

@@ -0,0 +1,14 @@
+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, strings, viewportHeight }: ScreenSurfaceProps) => import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+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 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

@@ -0,0 +1,13 @@
+import type { DropRegion } from '../DropRegions/DropRegion';
+export interface Rect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export type RectOf = (elementId: string) => Rect | undefined;
+export interface PlacedRegion {
+    region: DropRegion;
+    rect: Rect;
+}
+export declare function placeRegion(region: DropRegion, surface: Rect, rectOf: RectOf): Rect | 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/sameMeasurement.d.ts

@@ -0,0 +1,5 @@
+import type { PlacedRegion, Rect } from './dropRegionRects';
+declare const sameRect: (left: Rect | undefined, right: Rect | undefined) => boolean;
+export declare const sameRegions: (left: readonly PlacedRegion[], right: readonly PlacedRegion[]) => boolean;
+export declare const sameSelection: typeof sameRect;
+export {};

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 {};