@cratis/event-models 0.112.0 → 0.114.0

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

@@ -0,0 +1,9 @@
+import { type RefObject } from 'react';
+import type { DropRegion } from '../DropRegions/DropRegion';
+import { type PlacedRegion, type Rect } from './dropRegionRects';
+export interface SurfaceMeasurement {
+    placed: PlacedRegion[];
+    selectionRect: Rect | undefined;
+    measureNow: () => PlacedRegion[];
+}
+export declare function useSurfaceMeasurement(surface: RefObject<HTMLDivElement | null>, dropRegions: readonly DropRegion[], selectedId: string | undefined): SurfaceMeasurement;

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,32 @@
+export * from './Host/ScreenEditorOverlay';
+export * from './Host/ScreenEditorPrimeReactProvider';
+export * from './Host/screenEditorPrimeReactDefaults';
+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;

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

@@ -0,0 +1,18 @@
+import { ScenePackageBundle } from '@cratis/scene.react';
+import { ResolvedUiProfile } from './ResolvedUiProfile';
+import { UiProfileSettings } from './UiProfileSettings';
+/** The name of the Scene profile the workspace builds. */
+export declare const uiProfileName = "UI Profile";
+/**
+ * Expands the settings into the effective profile.
+ *
+ * Nothing here decides anything itself: `resolvePackageDependencies` expands and orders the packages,
+ * `findComponentCollisions` (`resolveComponentName` over the catalog) says who wins each shared name and
+ * `filterCompatibleThemes` narrows the themes. This function only records, per package, whether the user
+ * chose it and which resolved packages need it - the part a picker has to explain.
+ *
+ * @param settings The settings to resolve.
+ * @param bundles Every known package bundle.
+ * @returns The {@link ResolvedUiProfile}.
+ */
+export declare function resolveUiProfile(settings: UiProfileSettings, bundles: ScenePackageBundle[]): ResolvedUiProfile;

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

@@ -0,0 +1,10 @@
+import { ScenePackageBundle } from '@cratis/scene.react';
+/**
+ * The layout a blueprint contributes as the application shell: the first one its manifest declares.
+ *
+ * @param bundles Every known package bundle.
+ * @param shell The name of the blueprint.
+ * @returns The layout name, or empty when the blueprint is unknown or declares no layout (a template-only
+ * blueprint cannot be the shell).
+ */
+export declare function shellLayoutOf(bundles: ScenePackageBundle[], shell: string): string;

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

@@ -0,0 +1,12 @@
+import { UiProfile } from '@cratis/scene.model';
+import { PersistedUiProfile } from './PersistedUiProfile';
+/**
+ * Builds the Scene profile a stored UI profile stands for, without needing the package catalog.
+ *
+ * This is the one place a consumer other than the UI Profile page should turn the stored profile into a
+ * Scene `UiProfile`, so the screen editor and anything else rendering a screen agree with the preview.
+ *
+ * @param persisted The stored profile.
+ * @returns The Scene {@link UiProfile}.
+ */
+export declare function toSceneUiProfile(persisted: PersistedUiProfile): UiProfile;

package/dist/screen-editor/UiProfileDesigner/filterCompatibleThemes.d.ts

@@ -0,0 +1,12 @@
+import { Theme, UiProfile } from '@cratis/scene.model';
+/**
+ * Filters a theme list down to the ones a {@link UiProfile} can actually pick - part of StudioIssues#160's
+ * theme picker, filtered by the active profile's package list. Reuses `isThemeCompatible` (Cratis/Scene#5)
+ * unmodified as the filter predicate, per the issue's own wording ("reusing the exact compiler
+ * compatibility check as the filter logic rather than duplicating it").
+ *
+ * @param profile The active {@link UiProfile}.
+ * @param themes Every known {@link Theme}.
+ * @returns Only the themes declared compatible with every package `profile` lists.
+ */
+export declare function filterCompatibleThemes(profile: UiProfile, themes: Theme[]): Theme[];

package/dist/screen-editor/UiProfileDesigner/findComponentCollisions.d.ts

@@ -0,0 +1,15 @@
+import { UiProfile } from '@cratis/scene.model';
+import { ComponentResolution, PackageCatalog } from '@cratis/scene.engine';
+/**
+ * Finds every bare component name that more than one of a {@link UiProfile}'s active packages declares -
+ * part of StudioIssues#160's "component name collision surfacing", so the designer can flag which package
+ * currently wins by priority rather than only warning at build time. Reuses `resolveComponentName`
+ * (Cratis/Scene#3) unmodified for every catalog name - a collision is exactly a resolution whose
+ * `shadows` isn't empty, so no separate collision-detection algorithm exists to drift from resolution
+ * itself.
+ *
+ * @param profile The {@link UiProfile} to check.
+ * @param catalog Every active package's declared component names, keyed by package name.
+ * @returns The {@link ComponentResolution} for every bare name declared by more than one active package, sorted by name.
+ */
+export declare function findComponentCollisions(profile: UiProfile, catalog: PackageCatalog): ComponentResolution[];