@cratis/event-models 0.137.2 → 0.138.0

package/dist/screen-editor/ScreenEditor/Actions/ToolbarButtonClickKind.d.ts

@@ -0,0 +1,6 @@
+export declare enum ToolbarButtonClickKind {
+    None = "none",
+    Navigate = "navigate",
+    OpenDialog = "openDialog",
+    ExecuteCommand = "executeCommand"
+}

package/dist/screen-editor/ScreenEditor/Actions/toolbarButtonClick.d.ts

@@ -0,0 +1,9 @@
+import { type Behavior } from '@cratis/scene.model';
+import { ToolbarButtonClickKind } from './ToolbarButtonClickKind';
+export interface ToolbarButtonClick {
+    kind: ToolbarButtonClickKind;
+    target: string;
+}
+export declare const toolbarButtonClickBehavior = "studio.toolbarButton.click";
+export declare function readToolbarButtonClick(behaviors: readonly Behavior[] | undefined): ToolbarButtonClick;
+export declare function withToolbarButtonClick(behaviors: readonly Behavior[] | undefined, click: ToolbarButtonClick): Behavior[] | undefined;

package/dist/screen-editor/ScreenEditor/Destinations/DestinationProblemKind.d.ts

@@ -0,0 +1,11 @@
+export declare enum DestinationProblemKind {
+    NoTarget = "noTarget",
+    UnknownScreen = "unknownScreen",
+    InvalidRoute = "invalidRoute",
+    UnknownOutlet = "unknownOutlet",
+    UnknownDialog = "unknownDialog",
+    UnknownSlice = "unknownSlice",
+    OutletKindWithoutOutlet = "outletKindWithoutOutlet",
+    DialogKindWithoutDialog = "dialogKindWithoutDialog",
+    ExternalKindWithoutRoute = "externalKindWithoutRoute"
+}

package/dist/screen-editor/ScreenEditor/Destinations/destinationProblems.d.ts

@@ -0,0 +1,10 @@
+import { DestinationKind, type DestinationReference } from '@cratis/scene.model';
+import { DestinationProblemKind } from './DestinationProblemKind';
+export interface DestinationTargets {
+    screens: readonly string[];
+    outlets: readonly string[];
+    dialogTemplates: readonly string[];
+    slices: readonly string[];
+}
+export declare function destinationProblems(destination: DestinationReference | undefined, targets: DestinationTargets): DestinationProblemKind[];
+export declare function isValidRoute(route: string, kind?: DestinationKind): boolean;

package/dist/screen-editor/ScreenEditor/Destinations/destinationTargetsOf.d.ts

@@ -0,0 +1,5 @@
+import type { SceneDocument } from '@cratis/scene.model';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { DestinationTargets } from './destinationProblems';
+export declare function destinationTargetsOf(environment: ScreenEditorEnvironment, document: SceneDocument): DestinationTargets;
+export declare function unique(values: readonly string[]): string[];

package/dist/screen-editor/ScreenEditor/Document/updateElementInDocument.d.ts

@@ -0,0 +1,2 @@
+import type { SceneDocument, SceneElement } from '@cratis/scene.model';
+export declare function updateElementInDocument(document: SceneDocument, elementId: string, update: (element: SceneElement) => void): SceneDocument;

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

@@ -1,5 +1,5 @@
 import type { CanvasPlacement } from '../Document/placeOnCanvas';
-import type { DestinationReference, DialogTemplate, Form, NodeInspection, Outlet, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement } from '@cratis/scene.model';
+import type { Behavior, DestinationReference, DialogTemplate, Form, NodeInspection, Outlet, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement, ScreenTemplate, TemplateMetadata } from '@cratis/scene.model';
 import type { EditingContext } from '@cratis/scene.engine';
 import type { Ownership } from '../Structure/Ownership';
 import type { StructureEdit } from '../Structure/StructureEdit';
@@ -45,8 +45,12 @@ export interface ScreenEditorController {
     setProperty: (property: NodeInspection['properties'][number], value: unknown) => void;
     setScreenForms: (forms: Form[], label: string) => void;
     setScreenTemplateOutlets: (templateName: string, outlets: Outlet[], label: string) => void;
+    setScreenTemplateMetadata: (templateName: string, metadata: TemplateMetadata | undefined, label: string) => void;
     setDialogTemplates: (templates: DialogTemplate[], label: string) => void;
     setCollectionItemDestination: (componentId: string, path: string, itemId: string, destination: DestinationReference | undefined, label: string) => void;
+    setElementBehaviors: (elementId: string, behaviors: Behavior[] | undefined, label: string) => void;
+    setScreenTemplate: (template: ScreenTemplate | undefined, label: string) => void;
+    markSaved: () => void;
     undo: () => void;
     redo: () => void;
     canUndo: boolean;

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

@@ -1,4 +1,4 @@
-import type { SceneDocument } from '@cratis/scene.model';
+import type { SceneDocument, TemplateScope } from '@cratis/scene.model';
 import type { QueryCandidate } from '@cratis/scene.model';
 import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
 import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
@@ -23,6 +23,7 @@ export interface ScreenEditorEnvironment {
     availableSources: Record<string, string>;
     richText?: QuillLoader;
     fileUpload?: ScreenEditorFileUpload;
+    templateScope?: TemplateScope;
 }
 export interface ScreenEditorResult {
     document: SceneDocument;

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

@@ -24,5 +24,7 @@ export interface ScreenEditorWindowProps {
     window: ScreenEditorWindowState;
     deviceFrame?: boolean;
     saveFailure?: string;
+    onSave?: () => void;
+    isSaving?: boolean;
 }
-export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, deviceFrame, saveFailure }: ScreenEditorWindowProps) => import("react").JSX.Element;
+export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, deviceFrame, saveFailure, onSave, isSaving }: ScreenEditorWindowProps) => import("react").JSX.Element;

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

@@ -1,4 +1,5 @@
 import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
+import type { TemplateScope } from '@cratis/scene.model';
 import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
 import type { QuillLoader } from '@cratis/scene.primereact';
 import type { StateChangeSlice } from '../Actions/StateChangeSlice';
@@ -12,5 +13,6 @@ export interface ScreenEditorEnvironmentSource {
     destinations?: readonly ConfigurationDestination[];
     richText?: QuillLoader | false;
     fileUpload?: ScreenEditorFileUpload;
+    templateScope?: TemplateScope;
 }
 export declare function createScreenEditorEnvironment(source: ScreenEditorEnvironmentSource): ScreenEditorEnvironment;

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

@@ -1,4 +1,5 @@
-import type { DestinationReference } from '@cratis/scene.model';
+import { type DestinationReference } from '@cratis/scene.model';
+import type { DestinationProblemKind } from '../Destinations/DestinationProblemKind';
 import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
 import type { ScreenEditorStrings } from './ScreenEditorStrings';
 export interface DestinationReferenceFieldsProps {
@@ -8,8 +9,9 @@ export interface DestinationReferenceFieldsProps {
     destinations: readonly ConfigurationDestination[];
     outlets: readonly string[];
     dialogTemplates: readonly string[];
+    problems?: readonly DestinationProblemKind[];
     disabled: boolean;
     strings: ScreenEditorStrings['properties']['destination'];
     onChange: (destination: DestinationReference | undefined) => void;
 }
-export declare const DestinationReferenceFields: ({ id, label, value, destinations, outlets, dialogTemplates, disabled, strings, onChange }: DestinationReferenceFieldsProps) => import("react").JSX.Element;
+export declare const DestinationReferenceFields: ({ id, label, value, destinations, outlets, dialogTemplates, problems, disabled, strings, onChange }: DestinationReferenceFieldsProps) => import("react").JSX.Element;

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

@@ -5,6 +5,8 @@ import type { Ownership } from '../Structure/Ownership';
 import type { SceneDocumentProblem } from '../Document/readSceneDocument';
 import type { StructureEditRejection } from '../Structure/StructureEditRejection';
 import type { SurfaceStrings } from '../Surface/DesignTime/SurfaceStrings';
+import type { DestinationProblemKind } from '../Destinations/DestinationProblemKind';
+import type { TemplateInapplicability } from '../Templates/TemplateInapplicability';
 export interface ScreenEditorStrings {
     inspectorTitle: string;
     windowLabel: string;
@@ -42,6 +44,9 @@ export interface ScreenEditorStrings {
     closeDrawer: string;
     deleteElement: string;
     saveRefused: string;
+    save: string;
+    unsavedChanges: string;
+    allChangesSaved: string;
     properties: {
         diagnostics: string;
         noProperties: string;
@@ -69,6 +74,11 @@ export interface ScreenEditorStrings {
             scope: string;
             anyScope: string;
             missing: (template: string) => string;
+            search: string;
+            noMatches: string;
+            uncategorized: string;
+            provenance: (packageName: string) => string;
+            inapplicable: Record<TemplateInapplicability, string>;
         };
         outlets: {
             label: string;
@@ -91,6 +101,27 @@ export interface ScreenEditorStrings {
             outlet: string;
             dialog: string;
             clear: string;
+            kind: string;
+            kinds: {
+                default: string;
+                outlet: string;
+                dialog: string;
+                external: string;
+            };
+            problems: Record<DestinationProblemKind, string>;
+        };
+        toolbarButton: {
+            label: string;
+            onClick: string;
+            kinds: {
+                none: string;
+                navigate: string;
+                openDialog: string;
+                executeCommand: string;
+            };
+            target: string;
+            chooseTarget: string;
+            missingTarget: (target: string) => string;
         };
         dialogTemplates: {
             label: string;

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

@@ -0,0 +1,12 @@
+import type { TemplateScope } from '@cratis/scene.model';
+import { type TemplateBrowserPackage } from '../Templates/templateBrowser';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface TemplateBrowserProps {
+    packages: readonly TemplateBrowserPackage[];
+    scope: TemplateScope | undefined;
+    selected: string | undefined;
+    disabled: boolean;
+    strings: ScreenEditorStrings['properties']['templates'];
+    onSelect: (template: string | undefined) => void;
+}
+export declare const TemplateBrowser: ({ packages, scope, selected, disabled, strings, onSelect }: TemplateBrowserProps) => import("react").JSX.Element;

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

@@ -0,0 +1,15 @@
+import type { Behavior } from '@cratis/scene.model';
+import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
+import type { StateChangeSlice } from '../Actions/StateChangeSlice';
+import type { DestinationTargets } from '../Destinations/destinationProblems';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ToolbarButtonClickEditorProps {
+    behaviors: Behavior[] | undefined;
+    targets: DestinationTargets;
+    destinations: readonly ConfigurationDestination[];
+    slices: readonly StateChangeSlice[];
+    strings: ScreenEditorStrings['properties']['toolbarButton'];
+    disabled: boolean;
+    onChange: (behaviors: Behavior[] | undefined) => void;
+}
+export declare const ToolbarButtonClickEditor: ({ behaviors, targets, destinations, slices, strings, disabled, onChange }: ToolbarButtonClickEditorProps) => import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+export declare enum TemplateInapplicability {
+    OutOfScope = "outOfScope",
+    ShellOutsideApplication = "shellOutsideApplication"
+}

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

@@ -0,0 +1,2 @@
+import type { SceneDocument, ScreenTemplate } from '@cratis/scene.model';
+export declare function chooseScreenTemplate(document: SceneDocument, chosen: ScreenTemplate | undefined, packaged: readonly ScreenTemplate[]): SceneDocument;

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

@@ -0,0 +1,21 @@
+import { TemplateScope, type ScreenTemplate } from '@cratis/scene.model';
+import { TemplateInapplicability } from './TemplateInapplicability';
+export declare const applicationShellType = "ApplicationShell";
+export interface TemplateBrowserPackage {
+    manifest: {
+        name: string;
+    };
+    screenTemplates?: readonly ScreenTemplate[];
+}
+export interface TemplateBrowserEntry {
+    template: ScreenTemplate;
+    packageName: string;
+    label: string;
+    inapplicable?: TemplateInapplicability;
+}
+export interface TemplateBrowserCategory {
+    name: string;
+    entries: TemplateBrowserEntry[];
+}
+export declare function browseTemplates(packages: readonly TemplateBrowserPackage[], scope: TemplateScope | undefined, search: string): TemplateBrowserCategory[];
+export declare function inapplicabilityOf(template: ScreenTemplate, scope: TemplateScope | undefined): TemplateInapplicability | undefined;