@cratis/event-models 0.180.0 → 0.182.0

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

@@ -0,0 +1,89 @@
+import type { ComponentDesignModeDescriptor, InspectedProperty, SceneEdit } from '@cratis/scene.model';
+import type { NavigationEdit } from '@cratis/scene.engine';
+export declare const designModeActions: {
+    readonly addItem: 'addItem';
+    readonly addButton: 'addButton';
+    readonly rename: 'rename';
+    readonly target: 'target';
+    readonly slot: 'slot';
+    readonly slice: 'slice';
+    readonly emphasis: 'emphasis';
+    readonly moveEarlier: 'moveEarlier';
+    readonly moveLater: 'moveLater';
+    readonly duplicate: 'duplicate';
+    readonly delete: 'delete';
+    readonly addSubItem: 'addSubItem';
+};
+export declare enum DesignModeItemSourceKind {
+    Elements = "elements",
+    Collection = "collection",
+    Region = "region"
+}
+export interface DesignModeItem {
+    id: string;
+    label: string;
+    index: number;
+    count: number;
+    parentId?: string;
+    readOnly: boolean;
+    readOnlyReason?: string;
+    origin?: string;
+    values: Readonly<Record<string, unknown>>;
+    chips?: Readonly<Record<string, string>>;
+    problems?: readonly {
+        code: string;
+        message: string;
+    }[];
+    unlinked: boolean;
+}
+export interface DesignModeChoice {
+    property: InspectedProperty;
+    plan: (value: unknown) => DesignModePlan | DesignModeRejection;
+}
+export interface DesignModePlan {
+    label: string;
+    edits: SceneEdit[];
+    select?: {
+        elementId?: string;
+        itemId?: string | null;
+    };
+    renameNext?: boolean;
+    navigationEdits?: NavigationEdit[];
+    notice?: string;
+    editAtApplication?: boolean;
+}
+export interface DesignModeRejection {
+    rejected: string;
+}
+export declare const isRejection: (outcome: DesignModePlan | DesignModeRejection) => outcome is DesignModeRejection;
+export interface DesignModeReadOnlyAction {
+    id: string;
+    label: string;
+    plan: () => DesignModePlan | DesignModeRejection;
+}
+export interface DesignModeItemSource {
+    kind: DesignModeItemSourceKind;
+    items: readonly DesignModeItem[];
+    add: (actionId: string) => DesignModePlan | DesignModeRejection;
+    act: (actionId: string, item: DesignModeItem) => DesignModePlan | DesignModeRejection;
+    rename: (item: DesignModeItem, label: string) => DesignModePlan | DesignModeRejection;
+    choice: (actionId: string, item: DesignModeItem) => DesignModeChoice | undefined;
+    readOnlyActions: (item: DesignModeItem) => readonly DesignModeReadOnlyAction[];
+    regionTag?: {
+        text: string;
+        long: string;
+        kind: string;
+    };
+    region?: {
+        region: 'topbar' | 'sidebar';
+        module?: string;
+        mode?: 'inherit' | 'extend' | 'override';
+    };
+}
+export interface DesignModeSubject {
+    componentId: string;
+    componentName: string;
+    mode: ComponentDesignModeDescriptor;
+    source: DesignModeItemSource;
+    selected?: DesignModeItem;
+}

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

@@ -0,0 +1,22 @@
+import { type ApplicationStructure, type ExternalComponent, type NodeInspection } from '@cratis/scene.model';
+import { Ownership } from '../Structure/Ownership';
+import { type DesignModeItemSource } from './designModeTypes';
+export interface ElementItemKind {
+    slot: string;
+    componentName: string;
+    labelProperty: string;
+    startingLabel: string;
+    isUnlinked: (id: string, properties: Record<string, unknown>) => boolean;
+    startingProperties: Record<string, unknown>;
+}
+export declare const elementItemKinds: Readonly<Record<string, Omit<ElementItemKind, 'startingLabel'>>>;
+export interface ElementItemSourceInputs {
+    component: ExternalComponent;
+    addActionId: string;
+    ownershipOf: (elementId: string) => Ownership;
+    inspect: (elementId: string) => NodeInspection | undefined;
+    newId: () => string;
+    startingLabel: string;
+    structure?: ApplicationStructure;
+}
+export declare function createElementItemSource({ component, addActionId, ownershipOf, inspect, newId, startingLabel, structure }: ElementItemSourceInputs): DesignModeItemSource | undefined;

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

@@ -0,0 +1,18 @@
+import type { Rect } from '../Surface/dropRegionRects';
+export type ToolbarSide = 'above' | 'below';
+export interface ToolbarPlacementInputs {
+    anchor: Rect;
+    bounds: Rect;
+    size: {
+        width: number;
+        height: number;
+    };
+    prefer: ToolbarSide;
+    gap?: number;
+}
+export interface ToolbarPlacement {
+    left: number;
+    top: number;
+    side: ToolbarSide;
+}
+export declare function placeFloatingToolbar({ anchor, bounds, size, prefer, gap }: ToolbarPlacementInputs): ToolbarPlacement;

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

@@ -0,0 +1,21 @@
+import type { ApplicationStructure, DestinationReference, ExternalComponent, NodeInspection, SceneElement } from '@cratis/scene.model';
+import { type DescriptorCatalog } from '@cratis/scene.engine';
+import type { Ownership } from '../Structure/Ownership';
+import type { DesignModeItemSource, DesignModeSubject } from './designModeTypes';
+export interface DesignModeInputs {
+    roots: readonly SceneElement[];
+    catalog: DescriptorCatalog;
+    selectedId: string | undefined;
+    selectedItemId: string | undefined;
+    inspect: (elementId: string) => NodeInspection | undefined;
+    ownershipOf: (elementId: string) => Ownership;
+    newId: () => string;
+    startingLabels: {
+        button: string;
+        item: string;
+    };
+    structure?: ApplicationStructure;
+    startingDestination?: DestinationReference;
+    otherSource?: (component: ExternalComponent, selectedItemId: string | undefined) => DesignModeItemSource | undefined;
+}
+export declare function resolveDesignMode(inputs: DesignModeInputs): DesignModeSubject | undefined;

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

@@ -0,0 +1,31 @@
+import { NavigationRegionKind, type DestinationReference } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import { type DesignModeItem, type DesignModePlan, type DesignModeRejection, type DesignModeSubject } from './designModeTypes';
+import type { DesignModeStrings } from './DesignModeStrings';
+import { type DesignModeInputs } from './resolveDesignMode';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+export interface DesignModeOptions {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: DesignModeStrings;
+    startingLabels: {
+        button: string;
+        item: string;
+    };
+    startingDestination?: DestinationReference;
+    otherSource?: DesignModeInputs['otherSource'];
+}
+export interface DesignModeState {
+    subject: DesignModeSubject | undefined;
+    renameToken: number;
+    announcement: string;
+    notice: string;
+    pointItem: (componentId: string | undefined, itemId: string | undefined) => void;
+    perform: (outcome: DesignModePlan | DesignModeRejection, announce?: (plan: DesignModePlan) => string) => boolean;
+    add: (actionId: string) => boolean;
+    act: (actionId: string, item: DesignModeItem) => boolean;
+    rename: (item: DesignModeItem, label: string) => boolean;
+    deselect: () => void;
+}
+export declare function useDesignMode({ controller, environment, strings, startingLabels, startingDestination, otherSource }: DesignModeOptions): DesignModeState;
+export declare function regionOf(componentName: string): NavigationRegionKind | undefined;

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

@@ -0,0 +1,10 @@
+import { type RefObject } from 'react';
+import type { Rect } from '../Surface/dropRegionRects';
+import type { DesignModeSubject } from './designModeTypes';
+export interface DesignModeMeasurement {
+    surface: Rect;
+    component: Rect | undefined;
+    items: Readonly<Record<string, Rect>>;
+}
+export declare function useSurfaceMeasured<T>(surface: RefObject<HTMLDivElement | null>, compute: (root: HTMLDivElement, origin: DOMRect) => T | undefined, same: (a: T, b: T) => boolean): T | undefined;
+export declare function useDesignModeMeasurement(surface: RefObject<HTMLDivElement | null>, subject: DesignModeSubject | undefined): DesignModeMeasurement | undefined;

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

@@ -1,6 +1,6 @@
 import type { CanvasPlacement } from '../Document/placeOnCanvas';
-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 { ApplicationStructure, Behavior, DestinationReference, DialogTemplate, NavigationModel, Form, NodeInspection, Outlet, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement, ScreenTemplate, TemplateMetadata } from '@cratis/scene.model';
+import type { EditingContext, NavigationEdit } from '@cratis/scene.engine';
 import type { Ownership } from '../Structure/Ownership';
 import type { StructureEdit } from '../Structure/StructureEdit';
 import type { StructureEditRejection } from '../Structure/StructureEditRejection';
@@ -15,6 +15,16 @@ export type ElementMeasurer = (elementId: string) => {
     height: number;
 } | undefined;
 export interface ScreenEditorController {
+    navigation: NavigationModel;
+    structure: ApplicationStructure;
+    navigationModule: string | undefined;
+    applyNavigationEdits: (edits: NavigationEdit[], label: string) => {
+        applied: boolean;
+        rejected?: string;
+    };
+    setNavigationModule: (module: string | undefined) => void;
+    selectedItemId: string | undefined;
+    selectItem: (componentId: string | undefined, itemId: string | undefined) => void;
     document: SceneDocument;
     composition: EditorComposition;
     context: EditingContext;

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

@@ -1,3 +1,4 @@
+import type { ApplicationStructure } 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';
@@ -33,6 +34,12 @@ export interface ScreenEditorEnvironment {
         references?: (target: string) => readonly EditorReference[];
     };
     templateScope?: TemplateScope;
+    navigation?: ScreenEditorNavigation;
+}
+export interface ScreenEditorNavigation {
+    structure: ApplicationStructure;
+    module?: string;
+    slots?: readonly string[];
 }
 export interface ScreenEditorResult {
     document: SceneDocument;

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

@@ -1,6 +1,11 @@
-import type { SceneDiagnostic } from '@cratis/scene.model';
+export interface ListedDiagnostic {
+    code: string;
+    severity: string;
+    message: string;
+    path?: string | undefined;
+}
 export interface DiagnosticListProps {
-    diagnostics: readonly SceneDiagnostic[];
+    diagnostics: readonly ListedDiagnostic[];
     label: string;
 }
 export declare const DiagnosticList: ({ diagnostics, label }: DiagnosticListProps) => import("react").JSX.Element | null;

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

@@ -0,0 +1,13 @@
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface NavigationSectionProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+}
+export declare const slotNames: (text: {
+    mainArea: string;
+    sidePanel: string;
+}) => Record<string, string>;
+export declare const NavigationSection: ({ controller, environment, strings }: NavigationSectionProps) => import("react").JSX.Element | null;

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

@@ -7,8 +7,9 @@ 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 { DesignModeStrings } from '../DesignMode/DesignModeStrings';
 import type { DestinationProblemKind } from '../Destinations/DestinationProblemKind';
-import type { TemplateInapplicability } from '../Templates/TemplateInapplicability';
+import type { TemplatePickerLabels } from '../../TemplatePicker/TemplatePickerLabels';
 import type { TemplatePreviewSize } from '../Templates/TemplatePreviewSize';
 import type { TemplatePreviewState } from '@cratis/scene.blueprint.default';
 export interface ScreenEditorStrings {
@@ -40,6 +41,7 @@ export interface ScreenEditorStrings {
         close: string;
     };
     surface: SurfaceStrings;
+    designMode?: DesignModeStrings;
     undo: string;
     redo: string;
     palette: string;
@@ -84,12 +86,7 @@ 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>;
-            previewAction: string;
+            picker: TemplatePickerLabels;
             preview: (template: string) => string;
             previewState: string;
             previewStates: Record<TemplatePreviewState, string>;

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

@@ -0,0 +1,9 @@
+import type { SceneElement } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorStrings } from './ScreenEditorStrings';
+export interface ToolbarButtonSectionProps {
+    controller: ScreenEditorController;
+    strings: ScreenEditorStrings;
+    element: SceneElement;
+}
+export declare const ToolbarButtonSection: ({ controller, strings, element }: ToolbarButtonSectionProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Registry/PropertyEditorHost.d.ts

@@ -2,6 +2,7 @@ import type { InspectedProperty, SceneDiagnostic } from '@cratis/scene.model';
 import type { EditorContext, EditorProblem } from './PropertyEditorProps';
 import type { PropertyEditorRegistry } from './PropertyEditorRegistry';
 export interface PropertyEditorHostProps {
+    presentation?: 'field' | 'popover';
     registry: PropertyEditorRegistry;
     property: InspectedProperty;
     context: EditorContext;
@@ -9,5 +10,5 @@ export interface PropertyEditorHostProps {
     onChange: (property: InspectedProperty, value: unknown) => void;
     diagnostics: readonly SceneDiagnostic[];
 }
-export declare const PropertyEditorHost: ({ registry, property, context, componentId, onChange, diagnostics }: PropertyEditorHostProps) => import("react").JSX.Element;
+export declare const PropertyEditorHost: ({ registry, property, context, componentId, onChange, diagnostics, presentation }: PropertyEditorHostProps) => import("react").JSX.Element;
 export declare function problemOf(property: InspectedProperty, diagnostics: readonly SceneDiagnostic[]): EditorProblem | undefined;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Registry/PropertyEditorProps.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentType } from 'react';
 import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
-import type { InspectedProperty, PropertyDescriptor, QueryCandidate, QueryResultField, SceneDiagnostic, SceneDocument } from '@cratis/scene.model';
+import type { ApplicationStructure, InspectedProperty, PropertyDescriptor, QueryCandidate, QueryResultField, SceneDiagnostic, SceneDocument } from '@cratis/scene.model';
 import type { EffectiveIconCatalog } from '@cratis/scene.engine';
 import type { IconAdapterRegistry } from '@cratis/scene.react';
 import type { BindingTypeScope } from '@cratis/scene.engine';
@@ -41,6 +41,7 @@ export interface EditorLookups {
     slices: readonly EditorSlice[];
     destinations: readonly ConfigurationDestination[];
     slots: readonly string[];
+    structure?: ApplicationStructure;
     queryCandidates: readonly QueryCandidate[];
     availableSources: Readonly<Record<string, string>>;
     fields: readonly QueryResultField[];
@@ -82,6 +83,7 @@ export interface PropertyEditorProps<T = unknown> {
     disabled?: boolean;
     readOnlyReason?: string;
     problem?: EditorProblem;
+    inline?: boolean;
     id: string;
 }
 export interface EditorProblem {

package/dist/screen-editor/ScreenEditor/PropertyEditors/Registry/PropertyEditorStrings.d.ts

@@ -34,13 +34,24 @@ export interface PropertyEditorStrings {
         placeholder: string;
         unresolved: (target: string) => string;
     };
+    navigationItemTarget: {
+        notLinked: string;
+        module: string;
+        unresolved: (target: string) => string;
+    };
     renderingSlot: {
         none: string;
         diagram: (slot: string) => string;
+        names: Readonly<Record<string, string>>;
     };
     slice: {
         placeholder: string;
         notKind: (kind: string) => string;
+        kindName: (kind: string) => string;
+        sections: {
+            accepted: string;
+            refused: string;
+        };
     };
     inheritanceMode: {
         modes: Record<'inherit' | 'extend' | 'override', {

package/dist/screen-editor/ScreenEditor/PropertyEditors/Registry/SearchableSelect.d.ts

@@ -5,6 +5,8 @@ export interface SelectOption {
     group?: string;
     disabled?: boolean;
     reason?: string;
+    section?: string;
+    trailing?: string;
 }
 export declare function filterOptions(options: readonly SelectOption[], query: string): SelectOption[];
 export interface SearchableSelectProps {
@@ -18,9 +20,10 @@ export interface SearchableSelectProps {
     searchLabel: string;
     emptyLabel: string;
     clearLabel: string;
+    inline?: boolean;
     clearable?: boolean;
     renderClosed?: (option: SelectOption | undefined) => ReactNode;
     'aria-labelledby'?: string;
     'aria-describedby'?: string;
 }
-export declare const SearchableSelect: ({ id, options, value, onChange, disabled, invalid, placeholder, searchLabel, emptyLabel, clearLabel, clearable, renderClosed, ...aria }: SearchableSelectProps) => import("react").JSX.Element;
+export declare const SearchableSelect: ({ id, options, value, onChange, disabled, invalid, placeholder, searchLabel, emptyLabel, clearLabel, clearable, renderClosed, inline, ...aria }: SearchableSelectProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Registry/createEditorContext.d.ts

@@ -14,6 +14,7 @@ export interface EditorContextInputs {
     diagnostics: readonly SceneDiagnostic[];
     inCanvas: boolean;
     bindingScope: BindingTypeScope;
+    slotNames?: Readonly<Record<string, string>>;
 }
 export declare function fieldsOfBoundQuery(properties: Readonly<Record<string, unknown>> | undefined, candidates: readonly QueryCandidate[]): readonly QueryResultField[];
 export declare function createEditorContext(inputs: EditorContextInputs): EditorContext;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Specific/NavigationItemTargetEditor.d.ts

@@ -0,0 +1,16 @@
+import type { ApplicationStructure } from '@cratis/scene.model';
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export interface NavigationItemTarget {
+    module: string;
+    feature?: string;
+}
+interface Row {
+    key: string;
+    label: string;
+    depth: number;
+    target: NavigationItemTarget;
+    module: boolean;
+}
+export declare const rowsOf: (structure: ApplicationStructure) => Row[];
+export declare const NavigationItemTargetEditor: ({ value, onChange, context, disabled, id }: PropertyEditorProps<unknown>) => import("react").JSX.Element;
+export {};

package/dist/screen-editor/ScreenEditor/PropertyEditors/Specific/ReferenceTargetEditors.d.ts

@@ -1,3 +1,2 @@
 import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
-export declare const TemplateEditor: (props: PropertyEditorProps<string>) => import("react").JSX.Element;
 export declare const SampleDataEditor: (props: PropertyEditorProps<string>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Specific/SliceEditor.d.ts

@@ -2,4 +2,4 @@ import type { PropertyEditorProps, EditorLookups } from '../Registry/PropertyEdi
 import type { PropertyEditorStrings } from '../Registry/PropertyEditorStrings';
 import type { SelectOption } from '../Registry/SearchableSelect';
 export declare function sliceOptions(lookups: Pick<EditorLookups, 'slices' | 'stateChangeSlices'>, kinds: readonly string[] | undefined, text: PropertyEditorStrings): SelectOption[];
-export declare const SliceEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<string>) => import("react").JSX.Element;
+export declare const SliceEditor: ({ value, onChange, descriptor, context, disabled, problem, inline, id }: PropertyEditorProps<string>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Specific/TemplatePropertyEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const TemplatePropertyEditor: ({ value, onChange, context, disabled, id }: PropertyEditorProps<string>) => import("react").JSX.Element;

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

@@ -1,14 +1,16 @@
-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';
 import type { SurfaceStrings } from './DesignTime/SurfaceStrings';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
 export interface ScreenSurfaceProps {
     controller: ScreenEditorController;
     environment: ScreenEditorEnvironment;
     resolveBinding: BindingResolver;
     configuration?: EffectiveConfiguration;
     strings: SurfaceStrings;
+    editorStrings?: ScreenEditorStrings;
     viewportHeight?: number;
 }
-export declare const ScreenSurface: ({ controller, environment, resolveBinding, configuration, strings, viewportHeight }: ScreenSurfaceProps) => import("react").JSX.Element;
+export declare const ScreenSurface: ({ controller, environment, resolveBinding, configuration: given, strings, editorStrings, viewportHeight }: ScreenSurfaceProps) => import("react").JSX.Element;

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

@@ -7,3 +7,5 @@ export interface DesignTimePointerDecision {
 }
 export declare function decideDesignTimePointer(type: string, target: EventTarget | null, button?: number): DesignTimePointerDecision;
 export declare function elementIdAt(target: EventTarget | null): string | undefined;
+export declare const itemHitSelector = "[data-scene-item], [data-scene-nav-item]";
+export declare function itemIdAt(target: EventTarget | null): string | undefined;

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

@@ -1,2 +1,3 @@
 import type { Rect } from './dropRegionRects';
 export declare function elementRect(surface: Element, elementId: string, origin: DOMRect): Rect | undefined;
+export declare function nodeRect(node: Element, origin: DOMRect): Rect | undefined;

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) => void): void;
+export declare function useDesignTimePointer(surface: RefObject<HTMLElement | null>, select: (id: string | undefined, itemId?: string) => void): void;

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

@@ -0,0 +1,21 @@
+import { TemplateScope, type Layout, type UiProfile } from '@cratis/scene.model';
+import type { TemplateTarget } from '@cratis/scene.engine';
+/** What the screen editor knows about where the screen it edits sits - enough for Scene to say which templates apply. */
+export interface ScreenTemplateTargetInputs {
+    /** The packages in play, in ascending override priority. */
+    bundles: readonly {
+        layouts?: readonly Layout[];
+    }[];
+    /** The profile the screen is drawn under, which names the shell layout a template goes into. */
+    profile: Pick<UiProfile, 'layout'>;
+    /** Where in the application the screen sits; a screen of a slice unless the host says otherwise. */
+    scope?: TemplateScope;
+}
+/**
+ * The target the screen's templates are chosen for: the scope, and the profile's shell layout as the container a
+ * template has to fit a slot of. Without the container Scene cannot place a template that names a slot it fits.
+ *
+ * @param inputs Where the screen sits.
+ * @returns The Scene {@link TemplateTarget}.
+ */
+export declare function screenTemplateTarget({ bundles, profile, scope }: ScreenTemplateTargetInputs): TemplateTarget;

package/dist/screen-editor/ScreenEditor/Toolbar/slicesOfStructure.d.ts

@@ -0,0 +1,3 @@
+import type { ApplicationStructure } from '@cratis/scene.model';
+import type { EditorSlice } from '../PropertyEditors/Registry/PropertyEditorProps';
+export declare function slicesOfStructure(structure: ApplicationStructure | undefined): EditorSlice[];

package/dist/screen-editor/ScreenEditor/Toolbar/toolbarDiagnostics.d.ts

@@ -0,0 +1,8 @@
+import type { ApplicationStructure, SceneElement } from '@cratis/scene.model';
+export interface ToolbarFinding {
+    code: string;
+    severity: 'error' | 'warning';
+    message: string;
+    button: string;
+}
+export declare function toolbarDiagnostics(structure: ApplicationStructure, toolbar: SceneElement): ToolbarFinding[];

package/dist/screen-editor/ScreenEditor/Toolbar/upgradeToolbarButton.d.ts

@@ -0,0 +1,5 @@
+import { type ApplicationStructure, type SceneEdit } from '@cratis/scene.model';
+export declare function upgradeOf(structure: ApplicationStructure, id: string, properties: Record<string, unknown>): {
+    slice: string;
+} | undefined;
+export declare function upgradeEdits(id: string, slice: string): SceneEdit[];

package/dist/screen-editor/ScreenTemplates/TemplateReference.d.ts

@@ -0,0 +1,8 @@
+import { TemplateReferenceKind } from './TemplateReferenceKind';
+/** A screen template chosen at some level, without the template itself - what is stored. */
+export interface TemplateReference {
+    /** Where the template comes from. */
+    kind: TemplateReferenceKind;
+    /** The blueprint template's name, or the application template's identifier. */
+    id: string;
+}

package/dist/screen-editor/ScreenTemplates/TemplateReferenceKind.d.ts

@@ -0,0 +1,7 @@
+/** Where a chosen screen template comes from. */
+export declare enum TemplateReferenceKind {
+    /** A screen template a Scene package in the UI Profile contributes, identified by its name. */
+    Blueprint = "blueprint",
+    /** A screen template built for the application itself, identified by its identifier. */
+    Application = "application"
+}

package/dist/screen-editor/ScreenTemplates/toTemplateSources.d.ts

@@ -0,0 +1,18 @@
+import type { TemplateSource } from '@cratis/scene.engine';
+/** What a package contributes to the template library: its manifest and the templates and layouts it carries. */
+export interface TemplateSourceBundle {
+    manifest: TemplateSource['manifest'];
+    layouts?: TemplateSource['layouts'];
+    screenTemplates?: TemplateSource['screenTemplates'];
+    dialogTemplates?: TemplateSource['dialogTemplates'];
+}
+/**
+ * The packages as Scene's template library reads them, in the order given.
+ *
+ * A later package's template replaces an earlier one of the same name - the rule the whole UI Profile follows - so
+ * each source keeps only the templates that win, and the picker never lists the same name twice.
+ *
+ * @param bundles The packages, in ascending override priority.
+ * @returns The template sources.
+ */
+export declare function toTemplateSources(bundles: readonly TemplateSourceBundle[]): TemplateSource[];