@cratis/event-models 0.199.0 → 0.199.1

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/EditorNavigationScope.d.ts

@@ -1,10 +1,12 @@
 import { type ReactNode } from 'react';
-import type { ApplicationStructure, NavigationModel } from '@cratis/scene.model';
+import type { ApplicationStructure, DestinationReference, NavigationModel } from '@cratis/scene.model';
 export interface EditorNavigationScopeProps {
     structure: ApplicationStructure;
     navigation: NavigationModel;
     module: string | undefined;
     logoLockedReason: string;
+    onNavigate?: (destination: DestinationReference) => void;
+    peeking?: string;
     children: ReactNode;
 }
-export declare const EditorNavigationScope: ({ structure, navigation, module, logoLockedReason, children }: EditorNavigationScopeProps) => import("react").JSX.Element;
+export declare const EditorNavigationScope: ({ structure, navigation, module, logoLockedReason, onNavigate, peeking, children }: EditorNavigationScopeProps) => import("react").JSX.Element;

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

@@ -23,10 +23,11 @@ export interface ScreenEditorWindowProps {
     environment: ScreenEditorEnvironment;
     strings: ScreenEditorStrings;
     window: ScreenEditorWindowState;
+    authoringTemplate?: string;
     deviceFrame?: boolean;
     saveFailure?: string;
     onSave?: () => void;
     isSaving?: boolean;
     onPreview?: (document: SceneDocument) => void;
 }
-export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, deviceFrame, saveFailure, onSave, isSaving, onPreview }: ScreenEditorWindowProps) => import("react").JSX.Element;
+export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, authoringTemplate, deviceFrame, saveFailure, onSave, isSaving, onPreview }: ScreenEditorWindowProps) => import("react").JSX.Element;

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

@@ -14,5 +14,6 @@ export interface ScreenEditorEnvironmentSource {
     richText?: QuillLoader | false;
     fileUpload?: ScreenEditorFileUpload;
     templateScope?: TemplateScope;
+    navigation?: ScreenEditorEnvironment['navigation'];
 }
 export declare function createScreenEditorEnvironment(source: ScreenEditorEnvironmentSource): ScreenEditorEnvironment;

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

@@ -20,6 +20,10 @@ export interface ScreenEditorStrings {
     openInspector: string;
     closeInspector: string;
     desktopPreview: string;
+    showApplicationShell: string;
+    hideApplicationShell: string;
+    shellPeeking: (name: string) => string;
+    shellPeekBack: string;
     mobilePreview: string;
     sizeClass: (width: string, height: string) => string;
     viewportSize: (width: number, height: number) => string;

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

@@ -4,6 +4,10 @@ export interface ViewportControlsProps {
     windowSize: ViewportSize;
     available: ViewportSize;
     strings: ScreenEditorStrings;
+    shell?: {
+        shown: boolean;
+        toggle: () => void;
+    };
     onResize: (size: ViewportSize) => void;
 }
-export declare const ViewportControls: ({ windowSize, available, strings, onResize }: ViewportControlsProps) => import("react").JSX.Element;
+export declare const ViewportControls: ({ windowSize, available, strings, shell, onResize }: ViewportControlsProps) => import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+export declare enum ShellPointer {
+    NotShell = "notShell",
+    Navigate = "navigate",
+    Ignore = "ignore"
+}
+export declare const screenSelector = "[data-scene-id=\"composition\"], [data-studio-element=\"composition\"]";
+export declare const navigationEntrySelector = "[data-scene-nav-item], [data-target-screen]";
+export declare function decideShellPointer(target: EventTarget | null, shellShown: boolean): ShellPointer;

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

@@ -0,0 +1,11 @@
+import { type SceneDocument, type SceneElement } from '@cratis/scene.model';
+import type { EffectiveShell, TemplateLibrary } from '@cratis/scene.engine';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+export declare function shellLibraryOf(runtime: ScreenEditorRuntime, document: SceneDocument): TemplateLibrary;
+export declare const shellContentId = "studio-shell-content";
+export interface ShellFrame {
+    element: SceneElement;
+    shell: EffectiveShell;
+}
+export declare function effectiveShellFor(runtime: ScreenEditorRuntime, document: SceneDocument): EffectiveShell;
+export declare function composeShellFrame(runtime: ScreenEditorRuntime, document: SceneDocument): ShellFrame;

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

@@ -0,0 +1,4 @@
+import { type DestinationReference, type SceneElement } from '@cratis/scene.model';
+export declare function peekNameOf(destination: DestinationReference): string;
+export declare function canPeek(destination: DestinationReference): boolean;
+export declare function peekElement(destination: DestinationReference, text: string): SceneElement;

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

@@ -0,0 +1,20 @@
+import type { SceneDocument } from '@cratis/scene.model';
+export declare enum ShellSubject {
+    Screen = "screen",
+    ScreenTemplate = "screenTemplate",
+    DialogTemplate = "dialogTemplate",
+    TheShell = "theShell"
+}
+export declare function shellSubjectOf(document: SceneDocument, authoringTemplate: string | undefined, shellName: string): ShellSubject;
+export declare const shellShownByDefault: (subject: ShellSubject) => boolean;
+export declare const shellCanFrame: (subject: ShellSubject) => boolean;
+export interface ShellPreferenceStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export interface ShellPreference {
+    read(subject: ShellSubject): boolean | undefined;
+    write(subject: ShellSubject, shown: boolean): void;
+}
+export declare const browserShellPreferenceStorage: () => ShellPreferenceStorage | undefined;
+export declare function createShellPreference(storage?: ShellPreferenceStorage | undefined): ShellPreference;

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

@@ -0,0 +1,2 @@
+import type { SceneElement } from '@cratis/scene.model';
+export declare function spliceContent(root: SceneElement, id: string, content: SceneElement): SceneElement;

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

@@ -0,0 +1,15 @@
+import type { DestinationReference, SceneDocument } from '@cratis/scene.model';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+import { type ShellFrame } from './frameInShell';
+import { type ShellPreference } from './shellVisibility';
+export interface ShellState {
+    available: boolean;
+    shown: boolean;
+    toggle(): void;
+    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): ShellState;

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

@@ -4,6 +4,7 @@ import type { ScreenEditorController } from '../Host/ScreenEditorController';
 import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
 import type { SurfaceStrings } from './DesignTime/SurfaceStrings';
 import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import type { ShellState } from '../ShellFrame/useShellFrame';
 export interface ScreenSurfaceProps {
     controller: ScreenEditorController;
     environment: ScreenEditorEnvironment;
@@ -12,5 +13,6 @@ export interface ScreenSurfaceProps {
     strings: SurfaceStrings;
     editorStrings?: ScreenEditorStrings;
     viewportHeight?: number;
+    shell?: ShellState;
 }
-export declare const ScreenSurface: ({ controller, environment, resolveBinding, configuration: given, strings, editorStrings, viewportHeight }: ScreenSurfaceProps) => import("react").JSX.Element;
+export declare const ScreenSurface: ({ controller, environment, resolveBinding, configuration: given, strings, editorStrings, viewportHeight, shell }: ScreenSurfaceProps) => import("react").JSX.Element;

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

@@ -1,2 +1,2 @@
 import { type RefObject } from 'react';
-export declare function useDesignTimePointer(surface: RefObject<HTMLElement | null>, select: (id: string | undefined, itemId?: string) => void): void;
+export declare function useDesignTimePointer(surface: RefObject<HTMLElement | null>, select: (id: string | undefined, itemId?: string) => void, shellShown?: boolean): void;

package/dist/screen-editor/UiProfile/UiProfileSettings.d.ts

@@ -1,4 +1,5 @@
 import { ColorScheme, LayoutMode } from '@cratis/scene.blueprint.default';
+import type { RootTemplate } from '@cratis/scene.model';
 import type { SampleDataSelectionSettings } from './SampleDataSelectionSettings';
 /**
  * The choices that make up an application's UI profile - what a draft edits and what applying persists.
@@ -13,8 +14,13 @@ export interface UiProfileSettings {
      * in ascending override priority. `core` is never listed: it is always the final fallback.
      */
     packages: string[];
-    /** The blueprint supplying the application shell, or empty when none is chosen. */
+    /** The blueprint supplying the application shell, or empty when none is chosen. For a root template that is the blueprint's, it names that blueprint. */
     shell: string;
+    /**
+     * The application's root template - its shell - and the options the shell is given. Absent for a profile that only names a blueprint
+     * (`shell`): the blueprint's first layout is then the shell. Scene's `resolveEffectiveShell` reads the same shape.
+     */
+    root?: RootTemplate;
     /** Further blueprints whose reusable templates are available without changing the shell. */
     templatePacks: string[];
     /** The name of the theme, or empty to take the first one compatible with the profile. */

package/dist/screen-editor/UiProfile/rootLayoutOf.d.ts

@@ -0,0 +1,10 @@
+import { ScenePackageBundle } from '@cratis/scene.react';
+import { UiProfileSettings } from './UiProfileSettings';
+/**
+ * The layout the profile's root template names, when the root is a blueprint's layout the bundles know.
+ *
+ * @param settings The settings to read.
+ * @param bundles Every known package bundle.
+ * @returns The layout name, or `undefined` when the profile has no such root (the shell's first layout is then the shell).
+ */
+export declare function rootLayoutOf(settings: UiProfileSettings, bundles: ScenePackageBundle[]): string | undefined;