@cratis/event-models 0.111.1 → 0.113.0

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/isJsonValueType.d.ts

@@ -0,0 +1,4 @@
+import { PropertyValueType, type InspectedProperty } from '@cratis/scene.model';
+export declare const jsonValueType = PropertyValueType.Json;
+export declare const isJsonValueType: (valueType: string) => boolean;
+export declare const isJsonProperty: (property: InspectedProperty) => boolean;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/jsonDraft.d.ts

@@ -0,0 +1,11 @@
+import type { JsonDraftOutcome } from './JsonDraftOutcome';
+import type { JsonDraftState } from './JsonDraftState';
+export declare const startJsonDraft: (value: unknown) => JsonDraftState;
+export declare const editJsonDraft: (state: JsonDraftState, text: string) => JsonDraftState;
+export declare const syncJsonDraft: (state: JsonDraftState, value: unknown) => JsonDraftState;
+export declare const revertJsonDraft: (state: JsonDraftState) => JsonDraftState;
+export declare function resolveJsonDraft(state: JsonDraftState, required: boolean): JsonDraftOutcome;
+export declare function commitJsonDraft(state: JsonDraftState, required: boolean): {
+    state: JsonDraftState;
+    outcome: JsonDraftOutcome;
+};

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/numberLiteralsOf.d.ts

@@ -0,0 +1 @@
+export declare function numberLiteralsOf(text: string): string[];

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/readJson.d.ts

@@ -0,0 +1,2 @@
+import type { JsonReading } from './JsonReading';
+export declare function readJson(text: string): JsonReading;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/sameJson.d.ts

@@ -0,0 +1 @@
+export declare function sameJson(left: unknown, right: unknown): boolean;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Json/useJsonDraft.d.ts

@@ -0,0 +1,9 @@
+import type { JsonDraftOutcome } from './JsonDraftOutcome';
+export interface JsonDraft {
+    text: string;
+    outcome: JsonDraftOutcome;
+    edit: (text: string) => void;
+    commit: () => void;
+    revert: () => void;
+}
+export declare function useJsonDraft(value: unknown, required: boolean, onApply: (value: unknown) => void): JsonDraft;

package/dist/screen-editor/ScreenEditor/PrototypeProjection/LegacyExtras.d.ts

@@ -0,0 +1,11 @@
+export interface LegacyExtras {
+    top: Record<string, unknown>;
+    topKeys: string[];
+    canvas: Record<string, unknown>;
+    position: {
+        x: number;
+        y: number;
+    };
+    slots: Record<string, unknown>;
+    emptyName: boolean;
+}

package/dist/screen-editor/ScreenEditor/PrototypeProjection/applyLegacyState.d.ts

@@ -0,0 +1,3 @@
+export declare function applyLegacyState(element: object, top: Record<string, unknown>, zIndex: number): void;
+export declare function appliedState(top: Record<string, unknown>): Record<string, unknown>;
+export declare const stateFields: string[];

package/dist/screen-editor/ScreenEditor/PrototypeProjection/layoutContainerItems.d.ts

@@ -0,0 +1,4 @@
+import { LayoutItem } from '../Layouts/LayoutItem';
+export declare const legacyLayoutLibrary = "StudioLayout";
+export declare function layoutItemOfLegacyType(legacyType: string): LayoutItem | undefined;
+export declare function legacyTypeOfLayoutItem(item: LayoutItem): string;

package/dist/screen-editor/ScreenEditor/PrototypeProjection/legacyPlacement.d.ts

@@ -0,0 +1,5 @@
+export declare const canvasLeft = "Canvas.Left";
+export declare const canvasTop = "Canvas.Top";
+export declare const legacyTypeKey = "legacyType";
+export declare const legacyOriginalKey = "legacy";
+export declare const legacyExtrasKey = "legacyExtras";

package/dist/screen-editor/ScreenEditor/PrototypeProjection/projectToLegacyElements.d.ts

@@ -0,0 +1,3 @@
+import type { Panel } from '@cratis/scene.model';
+export type NativeLegacyType = (componentName: string) => string | undefined;
+export declare function projectToLegacyElements(root: Panel | undefined, nativeType?: NativeLegacyType): unknown[];

package/dist/screen-editor/ScreenEditor/PrototypeProjection/sceneComponentName.d.ts

@@ -0,0 +1,3 @@
+export declare function sceneComponentName(legacyType: string): string;
+export declare function legacyClassName(componentName: string): string;
+export declare function legacyLibrary(legacyType: string): string;

package/dist/screen-editor/ScreenEditor/PrototypeProjection/withoutNulls.d.ts

@@ -0,0 +1 @@
+export declare function withoutNulls<T>(value: T): T;

package/dist/screen-editor/ScreenEditor/Runtime/screenEditorRuntime.d.ts

@@ -0,0 +1,17 @@
+import { type DescriptorCatalog, type EffectiveIconCatalog, type PackageCatalog } from '@cratis/scene.engine';
+import type { ComponentDescriptor, UiProfile } from '@cratis/scene.model';
+import { type ComponentRegistry, type IconAdapterRegistry, type ScenePackageBundle } from '@cratis/scene.react';
+export interface ScreenEditorRuntime {
+    id: number;
+    bundles: ScenePackageBundle[];
+    registry: ComponentRegistry;
+    packages: PackageCatalog;
+    descriptors: ComponentDescriptor[];
+    catalog: DescriptorCatalog;
+    profile: UiProfile;
+    icons: EffectiveIconCatalog;
+    iconAdapters: IconAdapterRegistry;
+    isKnownComponent: (bareName: string) => boolean;
+    legacyTypeOf: (componentName: string) => string | undefined;
+}
+export declare function createScreenEditorRuntime(bundles: ScenePackageBundle[], profile: UiProfile): ScreenEditorRuntime;

package/dist/screen-editor/ScreenEditor/Runtime/screenEditorRuntimeForProfile.d.ts

@@ -0,0 +1,4 @@
+import type { ScenePackageBundle } from '@cratis/scene.react';
+import type { PersistedUiProfile } from '../../UiProfile/PersistedUiProfile';
+import { type ScreenEditorRuntime } from './screenEditorRuntime';
+export declare function screenEditorRuntimeForProfile(applied?: PersistedUiProfile, bundles?: ScenePackageBundle[]): ScreenEditorRuntime;

package/dist/screen-editor/ScreenEditor/Runtime/serverPrototypeTypes.d.ts

@@ -0,0 +1,3 @@
+export declare const unreadablePrototypeTypes: readonly string[];
+export declare const registeredPrototypeTypes: readonly string[];
+export declare const serverPrototypeTypes: ReadonlySet<string>;

package/dist/screen-editor/ScreenEditor/Runtime/useLoadedIconCatalog.d.ts

@@ -0,0 +1,2 @@
+import type { EffectiveIconCatalog } from '@cratis/scene.engine';
+export declare function useLoadedIconCatalog(catalog: EffectiveIconCatalog): number;

package/dist/screen-editor/ScreenEditor/Runtime/withActionPresentation.d.ts

@@ -0,0 +1,2 @@
+import { type ComponentDescriptor } from '@cratis/scene.model';
+export declare function withActionPresentation(descriptor: ComponentDescriptor): ComponentDescriptor;

package/dist/screen-editor/ScreenEditor/Runtime/withPlacementProperties.d.ts

@@ -0,0 +1,3 @@
+import { type ComponentDescriptor } from '@cratis/scene.model';
+export declare const placementGroup = "Placement";
+export declare function withPlacementProperties(descriptor: ComponentDescriptor): ComponentDescriptor;

package/dist/screen-editor/ScreenEditor/Selection/panelLayoutItem.d.ts

@@ -0,0 +1,3 @@
+import { type Panel } from '@cratis/scene.model';
+import { LayoutItem } from '../Layouts/LayoutItem';
+export declare function panelLayoutItem(panel: Panel): LayoutItem | undefined;

package/dist/screen-editor/ScreenEditor/Selection/sceneStructureAdapter.d.ts

@@ -0,0 +1,4 @@
+import type { SceneElement } from '@cratis/scene.model';
+import type { OwnershipResolver } from '../Structure/OwnershipResolver';
+import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
+export declare function createSceneStructureAdapter(ownershipOf: OwnershipResolver): StructureTreeAdapter<SceneElement>;

package/dist/screen-editor/ScreenEditor/Selection/sceneTree.d.ts

@@ -0,0 +1,4 @@
+import type { SceneElement } from '@cratis/scene.model';
+export declare function childrenOfElement(element: SceneElement): SceneElement[];
+export declare function everyElementId(roots: readonly SceneElement[]): string[];
+export declare function findSceneElement(roots: readonly SceneElement[], id: string): SceneElement | undefined;

package/dist/screen-editor/ScreenEditor/Selection/surfaceArrangementOfRoot.d.ts

@@ -0,0 +1,3 @@
+import type { Panel } from '@cratis/scene.model';
+import { LayoutArrangement } from '@cratis/scene/ScreenEditor';
+export declare function surfaceArrangementOfRoot(root: Panel | undefined): LayoutArrangement;

package/dist/screen-editor/ScreenEditor/Selection/surfaceLayoutOfRoot.d.ts

@@ -0,0 +1,3 @@
+import { PrototypeLayout } from '@cratis/scene';
+import { type Panel } from '@cratis/scene.model';
+export declare function surfaceLayoutOfRoot(root: Panel | undefined): PrototypeLayout;

package/dist/screen-editor/ScreenEditor/Selection/toSceneEdits.d.ts

@@ -0,0 +1,5 @@
+import { type InsertNodeEdit, type MoveNodeEdit, type RemoveNodeEdit, type SceneElement } from '@cratis/scene.model';
+import type { StructureEdit } from '../Structure/StructureEdit';
+export declare function toMoveNodeEdit(edit: StructureEdit): MoveNodeEdit | undefined;
+export declare function toInsertNodeEdit(parentId: string, index: number, element: SceneElement): InsertNodeEdit;
+export declare function toRemoveNodeEdit(elementId: string): RemoveNodeEdit;

package/dist/screen-editor/ScreenEditor/Session/EditSession.d.ts

@@ -0,0 +1,25 @@
+import type { SceneDiagnostic, SceneDocument, SceneEdit } from '@cratis/scene.model';
+import { type EditingContext } from '@cratis/scene.engine';
+interface Step {
+    before: SceneDocument;
+    label: string;
+}
+export interface ScreenEditSession {
+    document: SceneDocument;
+    undoable: readonly Step[];
+    redoable: readonly Step[];
+    diagnostics: SceneDiagnostic[];
+    isDirty: boolean;
+    savedDocument: SceneDocument;
+}
+export declare const maximumHistory = 100;
+export declare function openSession(document: SceneDocument): ScreenEditSession;
+export declare function applyToSession(session: ScreenEditSession, edit: SceneEdit, context: EditingContext, label: string): ScreenEditSession;
+export declare function applyAllToSession(session: ScreenEditSession, edits: SceneEdit[], context: EditingContext, label: string): ScreenEditSession;
+export declare const canUndo: (session: ScreenEditSession) => boolean;
+export declare const canRedo: (session: ScreenEditSession) => boolean;
+export declare function undo(session: ScreenEditSession): ScreenEditSession;
+export declare function redo(session: ScreenEditSession): ScreenEditSession;
+export declare function resetSession(document: SceneDocument): ScreenEditSession;
+export declare function markSaved(session: ScreenEditSession): ScreenEditSession;
+export {};

package/dist/screen-editor/ScreenEditor/Session/SessionCell.d.ts

@@ -0,0 +1,8 @@
+import type { ScreenEditSession } from './EditSession';
+export declare class SessionCell {
+    private latest;
+    private readonly publish;
+    constructor(latest: ScreenEditSession, publish: (session: ScreenEditSession) => void);
+    get current(): ScreenEditSession;
+    commit(change: (current: ScreenEditSession) => ScreenEditSession): ScreenEditSession;
+}

package/dist/screen-editor/ScreenEditor/Structure/DropZone.d.ts

@@ -0,0 +1,5 @@
+export declare enum DropZone {
+    Before = "before",
+    Inside = "inside",
+    After = "after"
+}

package/dist/screen-editor/ScreenEditor/Structure/MoveIntent.d.ts

@@ -0,0 +1,6 @@
+export declare enum MoveIntent {
+    MoveUp = "moveUp",
+    MoveDown = "moveDown",
+    Outdent = "outdent",
+    Indent = "indent"
+}

package/dist/screen-editor/ScreenEditor/Structure/Ownership.d.ts

@@ -0,0 +1,5 @@
+export declare enum Ownership {
+    Local = "local",
+    Inherited = "inherited",
+    ConfigurableInherited = "configurableInherited"
+}

package/dist/screen-editor/ScreenEditor/Structure/OwnershipResolver.d.ts

@@ -0,0 +1,2 @@
+import type { Ownership } from './Ownership';
+export type OwnershipResolver = (elementId: string) => Ownership;

package/dist/screen-editor/ScreenEditor/Structure/StructureEdit.d.ts

@@ -0,0 +1,5 @@
+export interface StructureEdit {
+    nodeId: string;
+    targetParentId: string | null;
+    index: number;
+}

package/dist/screen-editor/ScreenEditor/Structure/StructureEditRejection.d.ts

@@ -0,0 +1,9 @@
+export declare enum StructureEditRejection {
+    NodeNotFound = "nodeNotFound",
+    TargetNotFound = "targetNotFound",
+    TargetNotContainer = "targetNotContainer",
+    WouldCreateCycle = "wouldCreateCycle",
+    NodeLocked = "nodeLocked",
+    TargetLocked = "targetLocked",
+    NoChange = "noChange"
+}

package/dist/screen-editor/ScreenEditor/Structure/StructureLocation.d.ts

@@ -0,0 +1,6 @@
+export interface StructureLocation<T> {
+    node: T;
+    parent: T | null;
+    index: number;
+    siblings: T[];
+}

package/dist/screen-editor/ScreenEditor/Structure/StructureOperation.d.ts

@@ -0,0 +1,9 @@
+export declare enum StructureOperation {
+    Select = "select",
+    Configure = "configure",
+    Move = "move",
+    Resize = "resize",
+    Restyle = "restyle",
+    Insert = "insert",
+    Delete = "delete"
+}

package/dist/screen-editor/ScreenEditor/Structure/StructureRow.d.ts

@@ -0,0 +1,8 @@
+export interface StructureRow<T> {
+    node: T;
+    id: string;
+    depth: number;
+    parentId: string | null;
+    hasChildren: boolean;
+    isExpanded: boolean;
+}

package/dist/screen-editor/ScreenEditor/Structure/StructureTreeAdapter.d.ts

@@ -0,0 +1,11 @@
+import type { LayoutArrangement } from '@cratis/scene/ScreenEditor';
+import type { Ownership } from './Ownership';
+export interface StructureTreeAdapter<T> {
+    idOf(node: T): string;
+    nameOf(node: T): string;
+    childrenOf(node: T): T[];
+    withChildren(node: T, children: T[]): T;
+    acceptsChildren(node: T): boolean;
+    ownershipOf(node: T): Ownership;
+    arrangementOf(node: T): LayoutArrangement | undefined;
+}

package/dist/screen-editor/ScreenEditor/Structure/findStructureNode.d.ts

@@ -0,0 +1,4 @@
+import type { StructureLocation } from './StructureLocation';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function findStructureNode<T>(roots: T[], id: string, adapter: StructureTreeAdapter<T>, parent?: T | null): StructureLocation<T> | undefined;
+export declare function isWithinStructureNode<T>(node: T, id: string, adapter: StructureTreeAdapter<T>): boolean;

package/dist/screen-editor/ScreenEditor/Structure/flattenStructure.d.ts

@@ -0,0 +1,3 @@
+import type { StructureRow } from './StructureRow';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function flattenStructure<T>(roots: T[], expandedIds: ReadonlySet<string>, adapter: StructureTreeAdapter<T>, depth?: number, parentId?: string | null): StructureRow<T>[];

package/dist/screen-editor/ScreenEditor/Structure/isOperationPermitted.d.ts

@@ -0,0 +1,3 @@
+import { Ownership } from './Ownership';
+import { StructureOperation } from './StructureOperation';
+export declare function isOperationPermitted(ownership: Ownership, operation: StructureOperation): boolean;

package/dist/screen-editor/ScreenEditor/Structure/resolveMoveIntentEdit.d.ts

@@ -0,0 +1,4 @@
+import { MoveIntent } from './MoveIntent';
+import type { StructureEdit } from './StructureEdit';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function resolveMoveIntentEdit<T>(roots: T[], nodeId: string, intent: MoveIntent, adapter: StructureTreeAdapter<T>): StructureEdit | undefined;

package/dist/screen-editor/ScreenEditor/Structure/resolveTreeDrop.d.ts

@@ -0,0 +1,4 @@
+import { DropZone } from './DropZone';
+import type { StructureEdit } from './StructureEdit';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function resolveTreeDrop<T>(roots: T[], movedId: string, targetId: string, zone: DropZone, adapter: StructureTreeAdapter<T>): StructureEdit | undefined;

package/dist/screen-editor/ScreenEditor/Structure/validateStructureEdit.d.ts

@@ -0,0 +1,4 @@
+import type { StructureEdit } from './StructureEdit';
+import { StructureEditRejection } from './StructureEditRejection';
+import type { StructureTreeAdapter } from './StructureTreeAdapter';
+export declare function validateStructureEdit<T>(roots: T[], edit: StructureEdit, adapter: StructureTreeAdapter<T>): StructureEditRejection | undefined;

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

@@ -0,0 +1,11 @@
+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';
+export interface ScreenSurfaceProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    resolveBinding: BindingResolver;
+    configuration?: EffectiveConfiguration;
+}
+export declare const ScreenSurface: ({ controller, environment, resolveBinding, configuration }: ScreenSurfaceProps) => import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { DragEvent } from 'react';
+import { type PalettePayload } from '../Palette/PaletteEntry';
+export declare const paletteMediaType = "application/x-studio-palette-item";
+export declare const elementMediaType = "application/x-studio-element";
+export declare const setPaletteDrag: (event: DragEvent, payload: PalettePayload) => void;
+export declare function readPaletteDrag(event: Pick<DragEvent, 'dataTransfer'>): PalettePayload | undefined;
+export declare const isPaletteDrag: (event: Pick<DragEvent, 'dataTransfer'>) => boolean;

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

@@ -0,0 +1,14 @@
+import type { DropRegion } from '../DropRegions/DropRegion';
+export interface Rect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export type RectOf = (elementId: string) => Rect | undefined;
+export interface PlacedRegion {
+    region: DropRegion;
+    rect: Rect;
+}
+export declare function placeRegion(region: DropRegion, surface: Rect, rectOf: RectOf): Rect | undefined;
+export declare function regionAt(regions: readonly PlacedRegion[], x: number, y: number, slop?: number): PlacedRegion | undefined;

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

@@ -0,0 +1,5 @@
+import type { PlacedRegion, Rect } from './dropRegionRects';
+declare const sameRect: (left: Rect | undefined, right: Rect | undefined) => boolean;
+export declare const sameRegions: (left: readonly PlacedRegion[], right: readonly PlacedRegion[]) => boolean;
+export declare const sameSelection: typeof sameRect;
+export {};

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

@@ -0,0 +1,8 @@
+import { type Panel, type SceneDocument, type SceneElement } from '@cratis/scene.model';
+export declare const compositionId = "composition";
+export interface EditorComposition {
+    element: Panel;
+    roots: SceneElement[];
+    templates: string[];
+}
+export declare function composeEditorScreen(document: SceneDocument, authoredTemplate?: string): EditorComposition;

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

@@ -0,0 +1,6 @@
+import { ProvenanceKind, type SceneDocument, type SceneElement } from '@cratis/scene.model';
+import { type EditingContext } from '@cratis/scene.engine';
+import { Ownership } from '../Structure/Ownership';
+import type { OwnershipResolver } from '../Structure/OwnershipResolver';
+export declare function ownershipOfProvenance(kind: `${ProvenanceKind}`): Ownership;
+export declare function resolveOwnership(document: SceneDocument, roots: SceneElement[], context: EditingContext): OwnershipResolver;

package/dist/screen-editor/ScreenEditor/Viewport/ViewportPreset.d.ts

@@ -0,0 +1,4 @@
+export declare enum ViewportPreset {
+    Desktop = "desktop",
+    Mobile = "mobile"
+}

package/dist/screen-editor/ScreenEditor/Viewport/ViewportSize.d.ts

@@ -0,0 +1,4 @@
+export interface ViewportSize {
+    width: number;
+    height: number;
+}

package/dist/screen-editor/ScreenEditor/Viewport/detectViewportPreset.d.ts

@@ -0,0 +1,3 @@
+import { ViewportPreset } from './ViewportPreset';
+import type { ViewportSize } from './ViewportSize';
+export declare function detectViewportPreset(windowSize: ViewportSize, available: ViewportSize): ViewportPreset | undefined;

package/dist/screen-editor/ScreenEditor/Viewport/resolveViewportSizeClass.d.ts

@@ -0,0 +1,3 @@
+import type { SizeClass } from '@cratis/scene.model';
+import type { ViewportSize } from './ViewportSize';
+export declare function resolveViewportSizeClass(windowSize: ViewportSize): SizeClass;

package/dist/screen-editor/ScreenEditor/Viewport/toWindowSize.d.ts

@@ -0,0 +1,3 @@
+import type { ViewportSize } from './ViewportSize';
+export declare function toWindowSize(viewport: ViewportSize, available: ViewportSize): ViewportSize;
+export declare function toViewport(windowSize: ViewportSize): ViewportSize;

package/dist/screen-editor/ScreenEditor/Viewport/viewportPresets.d.ts

@@ -0,0 +1,4 @@
+import { ViewportPreset } from './ViewportPreset';
+import type { ViewportSize } from './ViewportSize';
+export declare const windowChromeHeight = 40;
+export declare const viewportPresetSizes: Record<ViewportPreset, ViewportSize>;

package/dist/screen-editor/ScreenEditor/index.d.ts

@@ -0,0 +1,31 @@
+export * from './Host/ScreenEditorOverlay';
+export * from './Host/ScreenEditorPrimeReactProvider';
+export * from './Host/ScreenEditorWorkspace';
+export * from './Host/ScreenEditorWindow';
+export * from './Host/ScreenEditorController';
+export * from './Host/ScreenEditorHost';
+export * from './Host/ScreenEditorFileUpload';
+export * from './Host/createScreenEditorEnvironment';
+export * from './Runtime/screenEditorRuntime';
+export * from './Runtime/screenEditorRuntimeForProfile';
+export * from './Inspector/ScreenEditorStrings';
+export * from './Defaults/defaultScreenEditorStrings';
+export * from './PropertyEditors/Json/JsonPropertyField';
+export * from './PropertyEditors/Json/JsonPropertyFieldStrings';
+export * from './PropertyEditors/Json/defaultJsonPropertyFieldStrings';
+export * from './PropertyEditors/Json/isJsonValueType';
+export * from './PropertyEditors/Json/readJson';
+export * from './PropertyEditors/Json/formatJson';
+export * from './Defaults/defaultLayoutLabels';
+export * from './Defaults/defaultLayoutIcons';
+export * from './Defaults/defaultPaletteIcons';
+export * from './Defaults/defaultPaletteSources';
+export * from './Layouts/LayoutItem';
+export * from './Layouts/toLayoutContainerDescriptors';
+export * from './Palette/buildPalette';
+export * from './Actions/StateChangeSlice';
+export * from './Binding/toSceneCandidates';
+export * from './Document/readSceneDocument';
+export * from './Structure/Ownership';
+export * from './Structure/StructureEditRejection';
+export type { PersistedUiProfile } from '../UiProfile/PersistedUiProfile';

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

@@ -0,0 +1,9 @@
+/** Why a package is part of the resolved profile. */
+export declare enum PackageInclusion {
+    /** Always present: Scene's `core`, the final fallback every name resolves against. */
+    Fallback = "fallback",
+    /** Chosen by the user - as a library, the shell or a template pack. */
+    Explicit = "explicit",
+    /** Not chosen; present only because another package in the profile requires it. */
+    Automatic = "automatic"
+}

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

@@ -0,0 +1,19 @@
+/**
+ * A UI profile as it is stored: plain strings, so the host's generated proxy class satisfies it
+ * structurally without this package knowing about the host.
+ *
+ * It carries the resolved package order and the shell's layout as well as the choices, so a consumer that
+ * has no package catalog - Play, for one - can still build a Scene `UiProfile` from it.
+ */
+export interface PersistedUiProfile {
+    packages: string[];
+    shell: string;
+    templatePacks: string[];
+    resolvedPackages: string[];
+    layout: string;
+    theme: string;
+    colorScheme: string;
+    navigationMode: string;
+    accent: string;
+    defaultScreenTemplate: string;
+}

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

@@ -0,0 +1,19 @@
+import { PackageKind } from '@cratis/scene.model';
+import { PackageInclusion } from './PackageInclusion';
+/** One package of the resolved profile, with the reason it is there. */
+export interface ResolvedPackageEntry {
+    /** The package name. */
+    name: string;
+    /** The name to show: the manifest's display name, else the package name. */
+    displayName: string;
+    /** The manifest's one-line description, when it has one. */
+    description?: string;
+    /** The package's version. */
+    version: string;
+    /** What the package contributes. */
+    kind: PackageKind;
+    /** Why the package is present. */
+    inclusion: PackageInclusion;
+    /** The other resolved packages that declare a dependency on this one, in resolved order. */
+    requiredBy: string[];
+}

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

@@ -0,0 +1,20 @@
+import { Theme, UiProfile } from '@cratis/scene.model';
+import { ComponentResolution, PackageSelection } from '@cratis/scene.engine';
+import { ResolvedPackageEntry } from './ResolvedPackageEntry';
+/** What a {@link UiProfileSettings} amounts to once Scene's resolver has expanded and ordered it. */
+export interface ResolvedUiProfile {
+    /** The resolver's own outcome: the ordered packages, what it added, and everything wrong. */
+    selection: PackageSelection;
+    /** The Scene profile preview, screen editor and Play render through. */
+    profile: UiProfile;
+    /** The resolved packages in override-priority order, each with its reason. */
+    entries: ResolvedPackageEntry[];
+    /** Every bare component name more than one active package declares, and which one wins it. */
+    collisions: ComponentResolution[];
+    /** The themes compatible with every package of the profile. */
+    compatibleThemes: Theme[];
+    /** The layout of the chosen shell, or empty when there is no usable shell. */
+    layout: string;
+    /** Whether the resolver found nothing missing, conflicting or cyclic. */
+    isValid: boolean;
+}

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

@@ -0,0 +1,29 @@
+import { ColorScheme, LayoutMode } from '@cratis/scene.blueprint.default';
+/**
+ * The choices that make up an application's UI profile - what a draft edits and what applying persists.
+ *
+ * Only the choices are stored. Which packages those choices pull in, in what order and why is always
+ * recomputed by Scene's resolver (`resolveUiProfile`), so a stored profile can never disagree with the
+ * packages it names about what they require.
+ */
+export interface UiProfileSettings {
+    /**
+     * The packages chosen explicitly - component libraries, styling, and any other group such as icons -
+     * 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. */
+    shell: string;
+    /** 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. */
+    theme: string;
+    /** Whether the shell renders light or dark. */
+    colorScheme: ColorScheme;
+    /** How the shell lays out its navigation. */
+    navigationMode: LayoutMode;
+    /** An accent color as `#rrggbb`, or empty to keep the theme's own. */
+    accent: string;
+    /** The screen template new screens start from, or empty for none. Chosen per level by Cratis/StudioIssues#396. */
+    defaultScreenTemplate: string;
+}

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

@@ -0,0 +1,13 @@
+import { ScenePackageBundle } from '@cratis/scene.react';
+import { UiProfileSettings } from './UiProfileSettings';
+/**
+ * The profile an application has before anyone applies one: the base component library, the styling
+ * packages and the first blueprint the catalog offers as the shell.
+ *
+ * Preview, the screen editor and Play all fall back to this when nothing has been applied, so an
+ * application without a stored profile still renders the same everywhere.
+ *
+ * @param bundles Every known package bundle.
+ * @returns The default settings.
+ */
+export declare function defaultUiProfileSettings(bundles: ScenePackageBundle[]): UiProfileSettings;

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

@@ -0,0 +1,10 @@
+import { UiProfileSettings } from './UiProfileSettings';
+/**
+ * Every package the settings name, in the order they are handed to the resolver: `core` first, then the
+ * libraries in priority order, then the shell, then the template packs. The resolver is a stable sort, so
+ * this order is what decides override priority among packages nothing forces apart.
+ *
+ * @param settings The settings to read.
+ * @returns The distinct explicit package names.
+ */
+export declare function explicitPackageNames(settings: UiProfileSettings): string[];

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

@@ -0,0 +1,11 @@
+/**
+ * Fills the `{name}` placeholders of a message.
+ *
+ * A placeholder with no value is left visible rather than removed, so a missing argument shows up as
+ * `{subject}` on screen instead of as a sentence with a silent hole in it.
+ *
+ * @param template The message, possibly containing `{name}` placeholders.
+ * @param values The values to substitute, by placeholder name.
+ * @returns The message with every known placeholder replaced.
+ */
+export declare function formatMessage(template: string, values: Record<string, string | undefined>): string;