@cratis/event-models 0.347.0 → 0.348.0

package/dist/screen-editor/{QueryBindingPropertyEditor-BzDtdbGf.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-DLo6sV-E.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/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/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/useEditingScene.d.ts

@@ -2,7 +2,7 @@ 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) => {
+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;

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