@cratis/event-models 0.345.0 → 0.347.0

package/dist/screen-editor/{QueryBindingPropertyEditor-BofsQo32.js → QueryBindingPropertyEditor-BzDtdbGf.js}

@@ -1,4 +1,4 @@
-import { F as N, P as E, c as B, d as F, f as I, h as L, l as j, m as M, t as k, u as Q } from "./DataBindingSections-wybsadzf.js";
+import { F as N, P as E, c as B, d as F, f as I, h as L, l as j, m as M, t as k, u as Q } from "./DataBindingSections-DLo6sV-E.js";
 import { useState as R } from "react";
 import { Fragment as S, jsx as o, jsxs as d } from "react/jsx-runtime";
 import { validateBinding as D } from "@cratis/scene.engine";

package/dist/screen-editor/ScreenEditor/DesignMode/designModeAnnouncements.d.ts

@@ -0,0 +1,9 @@
+import { type DesignModeItem } from './designModeTypes';
+import type { DesignModeStrings } from './DesignModeStrings';
+export declare const actionAnnouncement: (strings: DesignModeStrings, actionId: string, item: DesignModeItem) => string;
+export declare const refusalReasonOf: (result: {
+    rejected?: string;
+    diagnostics?: readonly {
+        message: string;
+    }[];
+}, label: string) => string;

package/dist/screen-editor/ScreenEditor/DesignMode/designModeSelection.d.ts

@@ -0,0 +1,9 @@
+import type { DesignModePlan } from './designModeTypes';
+import type { DesignModeStrings } from './DesignModeStrings';
+import type { RegionSourceInputs } from './Navigation/regionItemSource';
+export interface SelectionTarget {
+    select: (elementId: string | undefined) => void;
+    selectItem: (componentId: string | undefined, itemId: string | undefined) => void;
+}
+export declare function applyPlanSelection(target: SelectionTarget, select: DesignModePlan['select'], componentId: string | undefined): void;
+export declare function regionStringsOf(strings: DesignModeStrings): RegionSourceInputs['strings'];

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

@@ -0,0 +1,15 @@
+import type { Behavior, DestinationReference, DialogTemplate, Form, SceneDocument, ScreenTemplate, Slot, TemplateMetadata } from '@cratis/scene.model';
+import { type ScreenEditSession } from '../Session/EditSession';
+import type { ScreenEditorEnvironment } from './ScreenEditorHost';
+export declare const useDocumentSetters: (commit: (change: (current: ScreenEditSession) => ScreenEditSession) => unknown, environment: ScreenEditorEnvironment) => {
+    setScreenForms: (forms: Form[], label: string) => void;
+    changeDocument: (change: (document: SceneDocument) => SceneDocument, label: string) => {
+        applied: boolean;
+    };
+    setScreenTemplateSlots: (templateName: string, slots: Slot[], label: string) => void;
+    setScreenTemplateMetadata: (templateName: string, metadata: TemplateMetadata | undefined, label: string) => void;
+    setDialogTemplates: (dialogTemplates: DialogTemplate[], label: string) => void;
+    setCollectionItemDestination: (componentId: string, path: string, itemId: string, destination: DestinationReference | undefined, label: string) => void;
+    setScreenTemplate: (template: ScreenTemplate | undefined, label: string) => void;
+    setElementBehaviors: (elementId: string, behaviors: Behavior[] | undefined, label: string) => void;
+};

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

@@ -0,0 +1,15 @@
+import type { SceneEdit } from '@cratis/scene.model';
+import type { EditingContext } from '@cratis/scene.engine';
+import { type ScreenEditSession } from '../Session/EditSession';
+import type { SessionCell } from '../Session/SessionCell';
+export declare const useEditApplication: (cell: SessionCell, commit: (change: (current: ScreenEditSession) => ScreenEditSession) => ScreenEditSession, context: EditingContext) => {
+    tryApply: (edit: SceneEdit, label: string) => {
+        applied: boolean;
+        diagnostics: import("@cratis/scene.model").SceneDiagnostic[];
+    };
+    apply: (edit: SceneEdit, label: string) => void;
+    applyAll: (edits: SceneEdit[], label: string) => {
+        applied: boolean;
+        diagnostics: import("@cratis/scene.model").SceneDiagnostic[];
+    };
+};

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

@@ -0,0 +1,12 @@
+import type { SceneElement } from '@cratis/scene.model';
+import type { EditingContext } from '@cratis/scene.engine';
+import type { ScreenEditSession } from '../Session/EditSession';
+import type { ScreenEditorEnvironment } from './ScreenEditorHost';
+export declare const useEditingScene: (document: ScreenEditSession['document'], authoringTemplate: string | undefined, environment: ScreenEditorEnvironment) => {
+    context: EditingContext;
+    composition: import("../Templates/composeEditorScreen").EditorComposition;
+    ownershipOf: import("../Structure/OwnershipResolver").OwnershipResolver;
+    adapter: import("../Structure/StructureTreeAdapter").StructureTreeAdapter<SceneElement>;
+    authored: import("@cratis/scene.model").Panel | undefined;
+    dropRegions: import("../DropRegions/DropRegion").DropRegion[];
+};

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

@@ -0,0 +1,17 @@
+import { type NavigationEdit } from '@cratis/scene.engine';
+import { type ScreenEditSession } from '../Session/EditSession';
+import type { SessionCell } from '../Session/SessionCell';
+import type { ScreenEditorEnvironment } from './ScreenEditorHost';
+export declare const useNavigationEditing: (document: ScreenEditSession['document'], cell: SessionCell, commit: (change: (current: ScreenEditSession) => ScreenEditSession) => ScreenEditSession, environment: ScreenEditorEnvironment) => {
+    navigation: import("@cratis/scene.model").NavigationModel;
+    structure: import("@cratis/scene.model").ApplicationStructure;
+    navigationModule: string | undefined;
+    setNavigationModule: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
+    applyNavigationEdits: (edits: NavigationEdit[], label: string) => {
+        applied: boolean;
+        rejected: string | undefined;
+    } | {
+        rejected?: undefined;
+        applied: boolean;
+    };
+};

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

@@ -0,0 +1,39 @@
+import type { SceneEdit, SceneElement } from '@cratis/scene.model';
+import { type CanvasPlacement } from '../Document/placeOnCanvas';
+import { type BoxMeasure } from '../Document/canvasMoveEdits';
+import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
+import { StructureEditRejection } from '../Structure/StructureEditRejection';
+import type { SessionCell } from '../Session/SessionCell';
+import type { ScreenEditorController } from './ScreenEditorController';
+import type { ComponentInsertedListener } from './useScreenEditor';
+type Applied = {
+    applied: boolean;
+};
+type MoveEdit = Parameters<ScreenEditorController['move']>[0];
+export interface StructureOperationsInput {
+    cell: SessionCell;
+    composition: {
+        roots: SceneElement[];
+        entry?: string;
+    };
+    authored: {
+        id?: string;
+    } | undefined;
+    adapter: StructureTreeAdapter<SceneElement>;
+    authoringTemplate: string | undefined;
+    measureBox: BoxMeasure;
+    tryApply: (edit: SceneEdit, label: string) => Applied;
+    applyAll: (edits: SceneEdit[], label: string) => Applied;
+    setSelectedId: (change: string | undefined | ((current: string | undefined) => string | undefined)) => void;
+    onInserted?: ComponentInsertedListener;
+}
+export declare const useStructureOperations: (input: StructureOperationsInput) => {
+    move: (edit: MoveEdit, at?: CanvasPlacement) => StructureEditRejection | undefined;
+    insertElement: (element: SceneElement, parentId: string | undefined, index: number | undefined, label: string, at?: CanvasPlacement) => void;
+    remove: (elementId: string) => void;
+    canRemove: (elementId: string) => boolean;
+    validateMove: (edit: Parameters<ScreenEditorController['validateMove']>[0]) => StructureEditRejection | undefined;
+    insertComponent: (componentName: string, parentId: string | undefined, index: number | undefined, at?: CanvasPlacement) => void;
+    insertLayout: (item: Parameters<ScreenEditorController['insertLayout']>[0], parentId: string | undefined, index: number | undefined, at?: CanvasPlacement) => void;
+};
+export {};

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

@@ -0,0 +1,14 @@
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { PlacementEnvironment } from '../Placement/hookPlacement';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ActionPropertiesProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    elementId: string;
+    properties: Record<string, unknown> | undefined;
+    disabled: boolean;
+    placement?: PlacementEnvironment;
+}
+export declare const ActionProperties: ({ controller, environment, strings, elementId, properties, disabled, placement }: ActionPropertiesProps) => import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface CommandFormPropertiesProps {
+    elementId: string;
+    properties: Record<string, unknown> | undefined;
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    disabled: boolean;
+}
+export declare const CommandFormProperties: ({ elementId, properties, controller, environment, strings, disabled }: CommandFormPropertiesProps) => import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+import type { ScreenOutlets } from '../DesignMode/Outlets/screenOutlets';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+import type { Ownership } from '../Structure/Ownership';
+export interface ComponentPropertiesProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    ownership: Ownership | undefined;
+    authoringTemplate?: string;
+    selectedId: string;
+    selection: NonNullable<ScreenEditorController['selection']>;
+    inspection: NonNullable<ScreenEditorController['inspection']>;
+    screenOutlets: ScreenOutlets;
+}
+export declare const ComponentProperties: ({ controller, environment, strings, ownership, authoringTemplate, selectedId, selection, inspection, screenOutlets }: ComponentPropertiesProps) => import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+import type { ComponentDescriptor, ExternalComponent, InspectedProperty } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ExternalComponentSectionsProps {
+    component: ExternalComponent;
+    descriptor: ComponentDescriptor;
+    properties: InspectedProperty[];
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    disabled: boolean;
+}
+export declare const ExternalComponentSections: ({ component, descriptor, properties, controller, environment, strings, disabled }: ExternalComponentSectionsProps) => import("react").JSX.Element;

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

@@ -1,4 +1,4 @@
-import { type ChangeLayoutTypeEdit, type NodeInspection } from '@cratis/scene.model';
+import type { ChangeLayoutTypeEdit, NodeInspection } from '@cratis/scene.model';
 import type { SceneOrderedItem } from '../Collections/orderedItems';
 import type { ScreenEditorController } from '../Host/ScreenEditorController';
 import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';

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

@@ -0,0 +1,20 @@
+import type { InspectedProperty, SceneDiagnostic } from '@cratis/scene.model';
+import { PropertyEditorHost } from '../PropertyEditors/Registry/PropertyEditorHost';
+import { withSession, type EditorContextInputs } from '../PropertyEditors/Registry/createEditorContext';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+type EditorContext = Parameters<typeof withSession>[0];
+type Registry = Parameters<typeof PropertyEditorHost>[0]['registry'];
+export interface PropertyGroupsProps {
+    groups: {
+        name: string;
+        properties: InspectedProperty[];
+    }[];
+    selectedId: string;
+    registry: Registry;
+    baseContext: EditorContext;
+    editorInputs: EditorContextInputs;
+    diagnostics: SceneDiagnostic[];
+    onChange: ScreenEditorController['setProperty'];
+}
+export declare const PropertyGroups: ({ groups, selectedId, registry, baseContext, editorInputs, diagnostics, onChange }: PropertyGroupsProps) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ScreenPropertiesProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    authoringTemplate?: string;
+}
+export declare const ScreenProperties: ({ controller, environment, strings, authoringTemplate }: ScreenPropertiesProps) => import("react").JSX.Element;

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

@@ -0,0 +1,26 @@
+import { BindingMode, BindingSourceKind, PropertyValueType, type BindingExpression } from '@cratis/scene.model';
+import type { BindingSourceInventory } from '../Binding/bindingSources';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export type BindingStrings = ScreenEditorStrings['properties']['binding'];
+export declare enum LiteralEditorKind {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Null = "null",
+    Json = "json"
+}
+export interface SourceChoice {
+    kind: BindingSourceKind;
+    label: string;
+    disabled?: boolean;
+    reason?: string;
+}
+export declare function kindOf(binding: BindingExpression): BindingSourceKind;
+export declare function bindingShapedValue(value: unknown): unknown | undefined;
+export declare function modesFor(binding: BindingExpression): BindingMode[];
+export declare function normalize(binding: BindingExpression): BindingExpression;
+export declare function forKind(kind: BindingSourceKind, binding: BindingExpression): Partial<BindingExpression>;
+export declare function literalKindFor(value: unknown, targetType: PropertyValueType): LiteralEditorKind;
+export declare function literalSignature(value: unknown, targetType: PropertyValueType): string;
+export declare function defaultLiteralValue(kind: LiteralEditorKind): unknown;
+export declare function sourceKindChoices(binding: BindingExpression, accepted: readonly BindingSourceKind[], sources: BindingSourceInventory, text: BindingStrings): SourceChoice[];

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

@@ -1,4 +1,4 @@
-import { type BindingResolver } from '@cratis/scene.engine';
+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';

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

@@ -0,0 +1,10 @@
+export interface SelectionGripProps {
+    left: number;
+    top: number;
+    elementId: string;
+    name: string;
+    title: string;
+    onStart: (elementId: string) => void;
+    onEnd: () => void;
+}
+export declare const SelectionGrip: ({ left, top, elementId, name, title, onStart, onEnd }: SelectionGripProps) => import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+import type { SurfaceStrings } from './DesignTime/SurfaceStrings';
+import type { DragFeedback } from './useSurfaceDrop';
+export declare const selectedNameOf: (selection: object | undefined) => string;
+export declare const dropAnnouncement: (feedback: DragFeedback | undefined, strings: Pick<SurfaceStrings, 'dropDenied' | 'dropTarget'>) => string;

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

@@ -0,0 +1,7 @@
+import type { EffectiveConfiguration } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import type { ShellState } from '../ShellFrame/useShellFrame';
+export declare const useEffectiveConfiguration: (given: EffectiveConfiguration | undefined, controller: ScreenEditorController) => EffectiveConfiguration | undefined;
+export declare const useDrawnScreen: (controller: ScreenEditorController, environment: ScreenEditorEnvironment, shell: ShellState | undefined, editorStrings: ScreenEditorStrings | undefined) => import("@cratis/scene.model").SceneElement;

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

@@ -0,0 +1,5 @@
+import type { KeyboardEvent, RefObject } from 'react';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ShellState } from '../ShellFrame/useShellFrame';
+import type { useDesignMode } from '../DesignMode/useDesignMode';
+export declare const useSurfaceKeys: (surface: RefObject<HTMLDivElement | null>, controller: ScreenEditorController, designMode: ReturnType<typeof useDesignMode>, shell: ShellState | undefined) => (event: KeyboardEvent) => void;

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

@@ -0,0 +1,3 @@
+import { type RefObject } from 'react';
+import type { ElementMeasurer } from '../Host/ScreenEditorController';
+export declare const useSurfaceMeasurer: (surface: RefObject<HTMLDivElement | null>, setMeasurer: (measure: ElementMeasurer | undefined) => void) => void;

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

@@ -0,0 +1,2 @@
+import { type RefObject } from 'react';
+export declare const useSurfaceViewportHeight: (surface: RefObject<HTMLDivElement | null>, viewportHeight: number | undefined) => number | undefined;