@cratis/event-models 0.346.0 → 0.348.0

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

@@ -1,5 +1,5 @@
-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 { useState as R } from "react";
+import { R as N, c as E, d as B, f as F, h as I, l as L, m as j, t as M, u as Q, z as R } from "./DataBindingSections-BeQxUfQM.js";
+import { useState as k } from "react";
 import { Fragment as S, jsx as o, jsxs as d } from "react/jsx-runtime";
 import { validateBinding as D } from "@cratis/scene.engine";
 var c = /* @__PURE__ */ (function(r) {
@@ -15,8 +15,8 @@ function b(r, i, u, l) {
     isStorable: s.every((m) => m.severity !== "error")
   };
 }
-var V = (r) => r.origin.map((i) => i.name).join(" / "), T = ({ property: r, candidates: i, scope: u, strings: l, disabled: s, onChange: m }) => {
-  const t = l.properties.query, [g, y] = R(), h = Q(r.effectiveValue) ? r.effectiveValue : void 0, n = g ?? h, p = n ? i.find((e) => e.id === n.queryId) : void 0, _ = n ? b(r.descriptor, p, n, u).diagnostics : [], v = (e) => {
+var V = (r) => r.origin.map((i) => i.name).join(" / "), z = ({ property: r, candidates: i, scope: u, strings: l, disabled: s, onChange: m }) => {
+  const t = l.properties.query, [g, y] = k(), h = Q(r.effectiveValue) ? r.effectiveValue : void 0, n = g ?? h, p = n ? i.find((e) => e.id === n.queryId) : void 0, _ = n ? b(r.descriptor, p, n, u).diagnostics : [], v = (e) => {
     if (!e) {
       y(void 0), m(void 0);
       return;
@@ -37,7 +37,7 @@ var V = (r) => r.origin.map((i) => i.name).join(" / "), T = ({ property: r, cand
         value: n?.queryId ?? "",
         onChange: (e) => {
           const a = i.find((f) => f.id === e.target.value);
-          v(a ? B(a) : void 0);
+          v(a ? E(a) : void 0);
         },
         children: [
           /* @__PURE__ */ o("option", {
@@ -66,8 +66,8 @@ var V = (r) => r.origin.map((i) => i.name).join(" / "), T = ({ property: r, cand
       n && p && /* @__PURE__ */ d(S, { children: [p.parameters.length > 0 && /* @__PURE__ */ d("div", {
         className: "studio-editor-query__group",
         children: [/* @__PURE__ */ o("strong", { children: t.parameters }), p.parameters.map((e) => /* @__PURE__ */ d("label", { children: [/* @__PURE__ */ d("span", { children: [t.sourceFor(e.name), e.required ? " *" : ""] }), /* @__PURE__ */ d("select", {
-          value: M(n, e),
-          onChange: (a) => v(I(n, e.name, a.target.value)),
+          value: j(n, e),
+          onChange: (a) => v(F(n, e.name, a.target.value)),
           children: [/* @__PURE__ */ o("option", {
             value: "",
             children: t.noSource
@@ -82,8 +82,8 @@ var V = (r) => r.origin.map((i) => i.name).join(" / "), T = ({ property: r, cand
           className: "studio-editor-query__column",
           children: [/* @__PURE__ */ o("input", {
             type: "checkbox",
-            checked: j(n, e),
-            onChange: (a) => v(a.target.checked ? F(n, e.name) : L(n, e.name))
+            checked: L(n, e),
+            onChange: (a) => v(a.target.checked ? B(n, e.name) : I(n, e.name))
           }), /* @__PURE__ */ o("span", { children: t.showColumn(e.name) })]
         }, e.name))]
       })] }),
@@ -91,16 +91,16 @@ var V = (r) => r.origin.map((i) => i.name).join(" / "), T = ({ property: r, cand
         className: "studio-editor-query__preview",
         role: "status",
         "data-state": q,
-        children: $(q, t.preview)
+        children: T(q, t.preview)
       }),
-      /* @__PURE__ */ o(E, {
+      /* @__PURE__ */ o(N, {
         diagnostics: _,
         label: l.properties.diagnostics
       })
     ]
   });
 };
-function $(r, i) {
+function T(r, i) {
   switch (r) {
     case c.NoQuery:
       return i.noQuery;
@@ -120,14 +120,14 @@ var J = ({ value: r, onChange: i, context: u, disabled: l }) => {
   const { session: s } = u;
   if (!s) return null;
   const m = Q(r) ? r : void 0, t = m ? u.lookups.queryCandidates.find((g) => g.id === m.queryId) : void 0;
-  return /* @__PURE__ */ d(S, { children: [/* @__PURE__ */ o(T, {
+  return /* @__PURE__ */ d(S, { children: [/* @__PURE__ */ o(z, {
     property: s.property,
     candidates: u.lookups.queryCandidates,
     scope: s.bindingScope,
     strings: s.screenStrings,
     disabled: l === !0,
     onChange: i
-  }), m && t && /* @__PURE__ */ o(k, {
+  }), m && t && /* @__PURE__ */ o(M, {
     controller: s.controller,
     environment: s.environment,
     strings: s.screenStrings,
@@ -135,7 +135,7 @@ var J = ({ value: r, onChange: i, context: u, disabled: l }) => {
     candidate: t,
     disabled: l === !0,
     onChange: (g, y, h) => {
-      const n = h === "" ? s.bindingScope : N({
+      const n = h === "" ? s.bindingScope : R({
         ...s.bindingScope.types,
         [h]: y.type
       });

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

@@ -76,6 +76,7 @@ export interface DesignModeStrings {
         duplicated: (label: string) => string;
         removed: (label: string) => string;
         refused: (reason: string) => string;
+        nothingToAdd: string;
     };
 }
 export declare const defaultDesignModeStrings: DesignModeStrings;

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

@@ -0,0 +1,10 @@
+export interface DesignModeFeedback {
+    announcement: string;
+    notice: string;
+}
+export declare const refusedFeedback: (message: string) => DesignModeFeedback;
+export interface AddOffer {
+    disabled: boolean;
+    title: string;
+}
+export declare const addOfferOf: (label: string, readOnlyReason: string | undefined) => AddOffer;

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

@@ -18,6 +18,7 @@ export interface DesignModeOptions {
 }
 export interface DesignModeState {
     subject: DesignModeSubject | undefined;
+    readOnlyReason?: string;
     renameToken: number;
     announcement: string;
     notice: string;

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

@@ -21,6 +21,8 @@ export type ElementMeasurer = (elementId: string) => {
     height: number;
 } | undefined;
 export interface ScreenEditorController {
+    opensOverPage: boolean;
+    readOnlyReason?: string;
     navigation: NavigationModel;
     structure: ApplicationStructure;
     navigationModule: string | undefined;

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

@@ -20,6 +20,7 @@ export interface ScreenEditorSubject {
     screenTemplate?: string;
     screen?: string;
     select?: ScreenEditorSelection;
+    opensOverPage?: boolean;
 }
 export interface ScreenEditorSelection {
     componentId: string;

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

@@ -6,6 +6,7 @@ import type { ScreenEditorSelection, ScreenEditorSubject } from './ScreenEditorH
 export interface OpenedSubject {
     document: SceneDocument;
     select?: ScreenEditorSelection;
+    opensOverPage?: boolean;
 }
 export type OpenResult = {
     opened: true;

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, opensOverPage?: boolean) => {
+    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/ScreenEditorStrings.d.ts

@@ -24,6 +24,8 @@ export interface ScreenEditorStrings {
     showApplicationShell: string;
     hideApplicationShell: string;
     showTemplate: string;
+    opensAsDialog: string;
+    opensAsDrawer: string;
     hideTemplate: string;
     shellPeeking: (name: string) => string;
     shellPeekBack: string;

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

@@ -8,10 +8,11 @@ export interface ViewportControlsProps {
         shown: boolean;
         toggle: () => void;
     };
+    opensAs?: string;
     template?: {
         shown: boolean;
         toggle: () => void;
     };
     onResize: (size: ViewportSize) => void;
 }
-export declare const ViewportControls: ({ windowSize, available, strings, shell, template, onResize }: ViewportControlsProps) => import("react").JSX.Element;
+export declare const ViewportControls: ({ windowSize, available, strings, shell, opensAs, template, onResize }: ViewportControlsProps) => 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/Play/PlayScreen.d.ts

@@ -7,5 +7,6 @@ export interface PlayScreenViewProps {
     runtime: ScreenEditorRuntime;
     resolveBinding: BindingResolver;
     registry?: ComponentRegistry;
+    opensOverPage?: boolean;
 }
-export declare const PlayScreenView: ({ document, runtime, resolveBinding, registry }: PlayScreenViewProps) => import("react").JSX.Element;
+export declare const PlayScreenView: ({ document, runtime, resolveBinding, registry, opensOverPage }: PlayScreenViewProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Play/composePlayScreen.d.ts

@@ -1,7 +1,9 @@
-import type { EffectiveConfiguration, SceneDocument, SceneElement } from '@cratis/scene.model';
+import type { DialogTemplate, EffectiveConfiguration, SceneDocument, SceneElement } from '@cratis/scene.model';
 import { type DescriptorCatalog } from '@cratis/scene.engine';
+import { type DialogFrameDescription } from '../Templates/dialogPresentation';
 export interface PlayScreen {
     element: SceneElement;
     configuration?: EffectiveConfiguration;
+    dialog?: DialogFrameDescription;
 }
-export declare function composePlayScreen(document: SceneDocument, catalog: DescriptorCatalog): PlayScreen;
+export declare function composePlayScreen(document: SceneDocument, catalog: DescriptorCatalog, knownDialogTemplates?: readonly DialogTemplate[], pageTemplateNames?: readonly string[], opensOverPage?: boolean): PlayScreen;

package/dist/screen-editor/ScreenEditor/ShellFrame/shellVisibility.d.ts

@@ -1,11 +1,12 @@
-import type { SceneDocument } from '@cratis/scene.model';
+import type { DialogTemplate, SceneDocument } from '@cratis/scene.model';
 export declare enum ShellSubject {
     Screen = "screen",
+    DialogScreen = "dialogScreen",
     ScreenTemplate = "screenTemplate",
     DialogTemplate = "dialogTemplate",
     TheShell = "theShell"
 }
-export declare function shellSubjectOf(document: SceneDocument, authoringTemplate: string | undefined, shellName: string): ShellSubject;
+export declare function shellSubjectOf(document: SceneDocument, authoringTemplate: string | undefined, shellName: string, knownDialogTemplates?: readonly DialogTemplate[], pageTemplateNames?: readonly string[], opensOverPage?: boolean): ShellSubject;
 export declare const shellShownByDefault: (subject: ShellSubject) => boolean;
 export declare const templateShownByDefault: (_subject: ShellSubject) => boolean;
 export declare const templateCanFrame: (subject: ShellSubject) => boolean;

package/dist/screen-editor/ScreenEditor/ShellFrame/useShellFrame.d.ts

@@ -1,4 +1,5 @@
 import type { DestinationReference, SceneDocument } from '@cratis/scene.model';
+import { type DialogFrameDescription } from '../Templates/dialogPresentation';
 import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
 import { type ShellFrame } from './frameInShell';
 import { type ShellPreference } from './shellVisibility';
@@ -11,10 +12,11 @@ export interface ShellState {
         shown: boolean;
         toggle(): void;
     };
+    dialog?: DialogFrameDescription;
     frame?: ShellFrame;
     peeking?: DestinationReference;
     peekingName: string;
     navigate(destination: DestinationReference): void;
     back(): void;
 }
-export declare function useShellFrame(document: SceneDocument, runtime: ScreenEditorRuntime, authoringTemplate: string | undefined, preference?: ShellPreference, hasTemplate?: boolean): ShellState;
+export declare function useShellFrame(document: SceneDocument, runtime: ScreenEditorRuntime, authoringTemplate: string | undefined, preference?: ShellPreference, hasTemplate?: boolean, opensOverPage?: boolean): ShellState;

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

@@ -0,0 +1,6 @@
+import type { CSSProperties } from 'react';
+import type { DialogFrameDescription } from '../Templates/dialogPresentation';
+export declare function dialogFrameAttributes(frame: DialogFrameDescription | undefined): {
+    'data-studio-dialog'?: string;
+    style: CSSProperties;
+};

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;

package/dist/screen-editor/ScreenEditor/Templates/dialogActionsChrome.d.ts

@@ -1,9 +1,9 @@
 import { type DialogTemplate, type Layout, type Outlet, type SceneDocument, type SceneElement, type ScreenTemplate } from '@cratis/scene.model';
 export declare const dialogActionsChromeId = "dialog-actions-chrome";
 export declare const defaultDialogTemplateName = "FormDialog";
-export declare function screenFitsDialog(document: SceneDocument): boolean;
-export declare function dialogTemplateOf(document: SceneDocument): DialogTemplate;
+export declare function screenFitsDialog(document: SceneDocument, pageTemplateNames?: readonly string[], opensOverPage?: boolean, known?: readonly DialogTemplate[]): boolean;
+export declare function dialogTemplateOf(document: SceneDocument, known?: readonly DialogTemplate[]): DialogTemplate;
 export declare function dialogActionsOutletOf(template: DialogTemplate): Outlet | undefined;
-export declare function showsDialogActions(document: SceneDocument, templates?: readonly ScreenTemplate[], layouts?: readonly Layout[]): boolean;
+export declare function showsDialogActions(document: SceneDocument, templates?: readonly ScreenTemplate[], layouts?: readonly Layout[], opensOverPage?: boolean, known?: readonly DialogTemplate[]): boolean;
 export declare function documentWithChrome(document: SceneDocument, chrome: readonly SceneElement[]): SceneDocument;
 export declare function dialogActionsChrome(): SceneElement;

package/dist/screen-editor/ScreenEditor/Templates/dialogPresentation.d.ts

@@ -0,0 +1,13 @@
+import { type DialogTemplate, type SceneDocument, type Screen } from '@cratis/scene.model';
+export declare enum DialogPresentation {
+    Dialog = "dialog",
+    Drawer = "drawer"
+}
+export interface DialogFrameDescription {
+    presentation: DialogPresentation;
+    template?: string;
+    title?: string;
+}
+export declare function dialogTemplatesIn(document: Pick<SceneDocument, 'dialogTemplates'>, known?: readonly DialogTemplate[]): DialogTemplate[];
+export declare function screenPresentationOf(screen: Pick<Screen, 'fits' | 'screenTemplate'>, pageTemplateNames?: readonly string[], opensOverPage?: boolean, dialogTemplateNames?: readonly string[]): DialogPresentation | undefined;
+export declare function dialogFrameOf(document: SceneDocument, known?: readonly DialogTemplate[], pageTemplateNames?: readonly string[], opensOverPage?: boolean): DialogFrameDescription | undefined;

package/dist/screen-editor/ScreenEditor/Templates/displayedFits.d.ts

@@ -0,0 +1,6 @@
+import { ScreenFit, type DialogTemplate, type SceneDocument, type Screen } from '@cratis/scene.model';
+import type { ScenePackageBundle } from '@cratis/scene.react';
+export declare function displayedFitsOf(screen: Pick<Screen, 'fits' | 'screenTemplate'> | undefined, pageTemplateNames?: readonly string[], opensOverPage?: boolean, dialogTemplateNames?: readonly string[]): readonly ScreenFit[];
+export declare function dialogTemplateNamesOf(document: Pick<SceneDocument, 'dialogTemplates' | 'screenTemplates'> | undefined, known?: readonly Pick<DialogTemplate, 'name'>[]): string[];
+export declare function pageTemplateNamesOf(document: Pick<SceneDocument, 'screenTemplates'> | undefined, bundles?: readonly Pick<ScenePackageBundle, 'screenTemplates'>[]): string[];
+export declare function blueprintDialogTemplatesOf(bundles?: readonly Pick<ScenePackageBundle, 'dialogTemplates'>[]): DialogTemplate[];

package/dist/screen-editor/ScreenEditor/Thumbnail/ScreenThumbnail.d.ts

@@ -11,5 +11,6 @@ export interface ScreenThumbnailProps {
     openTitle?: string;
     onClick?: (event: MouseEvent<HTMLElement>) => void;
     placeholder?: ReactNode;
+    opensOverPage?: boolean;
 }
-export declare const ScreenThumbnail: ({ document, runtime, windowSize, width, title, openTitle, onClick, placeholder }: ScreenThumbnailProps) => import("react").JSX.Element;
+export declare const ScreenThumbnail: ({ document, runtime, windowSize, width, title, openTitle, onClick, placeholder, opensOverPage }: ScreenThumbnailProps) => import("react").JSX.Element;