@cratis/event-models 0.112.0 → 0.113.0

package/dist/screen-editor/BlueprintPreview/blueprintPreviewCatalog.d.ts

@@ -0,0 +1,57 @@
+import { ScenePackage, Theme } from '@cratis/scene.model';
+import { PackageCatalog } from '@cratis/scene.engine';
+import { ComponentRegistry, ScenePackageBundle } from '@cratis/scene.react';
+/**
+ * Every Scene package bundle Studio has loaded.
+ *
+ * This is the one thing Studio has that the blueprint package's own gallery preview does not: all four
+ * dependency bundles (and the Lucide icon library) are real npm dependencies here, so a screen naming `dataTable` or `tag` resolves to
+ * a component that actually exists. The blueprint deliberately takes no bundler dependency on PrimeReact
+ * or Cratis Components - a blueprint declares its dependencies in its manifest, not in its import graph -
+ * which is why its own preview falls back to a profile that ranks `core` first and accepts placeholders
+ * for everything else. Studio does not need that fallback and must not copy it.
+ *
+ * There is no backend slice behind this page, no read model and nothing persisted: the catalog is exactly
+ * what the running bundle has imported, read at module load.
+ */
+export declare const blueprintPreviewBundles: ScenePackageBundle[];
+/**
+ * The package catalog, taken from each bundle's own manifest.
+ *
+ * Read from the manifests rather than written out, because a hand-copied component list is a second
+ * source of truth that drifts the first time a package gains a component - and the only symptom is a
+ * dashed red placeholder in the middle of an otherwise fine screen.
+ */
+export declare const blueprintPreviewCatalog: ScenePackage[];
+/**
+ * The merged component registry every preview renders against.
+ *
+ * Registry keys carry their package name, so merging cannot collide and merge order does not matter -
+ * which package wins a *bare* name is decided later, by `resolveComponentName` walking the profile's
+ * priority order.
+ */
+export declare const blueprintPreviewRegistry: ComponentRegistry;
+/**
+ * The component-name catalog `resolveComponentName` resolves against, keyed by package name.
+ */
+export declare const blueprintPreviewComponentCatalog: PackageCatalog;
+/**
+ * Every theme any loaded package ships - the blueprint's two and PrimeReact's free PrimeTek presets.
+ *
+ * Deliberately unfiltered: `filterCompatibleThemes` is what narrows this to the themes a given profile
+ * can actually pick, and a picker fed a pre-narrowed list has nothing to narrow.
+ */
+export declare const blueprintPreviewThemes: Theme[];
+/**
+ * The blueprints available to preview.
+ *
+ * Two, and the second is the interesting one: `Cratis.Blueprint.Components` declares no layouts of its own
+ * and depends on `Cratis.Blueprint.Default` for the application shell, so selecting it pulls the default
+ * blueprint in behind it. That is a blueprint layered on a blueprint, and the dependency resolver treats
+ * it like any other - which is the whole point of the packages being declared rather than assumed.
+ */
+export declare const previewableBlueprints: ScenePackageBundle[];
+/**
+ * The blueprint previewed when the page opens.
+ */
+export declare const previewedBlueprint: ScenePackageBundle;

package/dist/screen-editor/BlueprintPreview/initialPackageSelection.d.ts

@@ -0,0 +1,18 @@
+import { ScenePackage } from '@cratis/scene.model';
+/**
+ * The selection the picker opens on: every base component library, every styling package, and the first
+ * blueprint.
+ *
+ * It stops there rather than pre-picking the closure. The libraries that *layer* on a base - the ones the
+ * blueprint declares a dependency on - are left to `resolvePackageDependencies` to add, so the page opens
+ * already showing what dependency resolution did on the user's behalf. A picker that started from the
+ * complete, already-closed selection would never demonstrate that, which is half of what this page exists
+ * for.
+ *
+ * The bases and the styling packages *are* pre-picked, because every later stage is gated on them: leaving
+ * them out would open the page with the interesting stage closed and nothing to click in it.
+ *
+ * @param catalog Every known package.
+ * @returns The package names to start from.
+ */
+export declare function initialPackageSelection(catalog: ScenePackage[]): string[];

package/dist/screen-editor/IconLibraries/Lucide/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lucideManifest';
+export * from './lucideCatalog';
+export * from './lucideAdapter';
+export * from './lucidePackage';

package/dist/screen-editor/IconLibraries/Lucide/lucideAdapter.d.ts

@@ -0,0 +1,2 @@
+import { IconAdapter } from '@cratis/scene.react';
+export declare const lucideAdapter: IconAdapter;

package/dist/screen-editor/IconLibraries/Lucide/lucideCatalog.d.ts

@@ -0,0 +1,2 @@
+import { IconCatalogSource } from '@cratis/scene.engine';
+export declare const lucideCatalog: IconCatalogSource;

package/dist/screen-editor/IconLibraries/Lucide/lucideManifest.d.ts

@@ -0,0 +1,3 @@
+import { ScenePackage } from '@cratis/scene.model';
+export declare const lucideLibraryName = "Cratis.Icons.Lucide";
+export declare const lucideManifest: ScenePackage;

package/dist/screen-editor/IconLibraries/Lucide/lucidePackage.d.ts

@@ -0,0 +1,2 @@
+import { ScenePackageBundle } from '@cratis/scene.react';
+export declare const lucidePackage: ScenePackageBundle;

package/dist/screen-editor/Icons/IconPickerCatalogState.d.ts

@@ -0,0 +1,5 @@
+import { IconPickerCatalogStatus } from '@cratis/components/IconPicker';
+export interface IconPickerCatalogState {
+    status: IconPickerCatalogStatus;
+    error?: string;
+}

package/dist/screen-editor/Icons/IconPropertyField.d.ts

@@ -0,0 +1,25 @@
+import { IconPickerAllowed, IconPickerLabels, IconPickerPlacement } from '@cratis/components/IconPicker';
+import { EffectiveIconCatalog } from '@cratis/scene.engine';
+import { IconReference } from '@cratis/scene.model';
+import { IconAdapterRegistry } from '@cratis/scene.react';
+import { IconPropertyFieldStrings } from './IconPropertyFieldStrings';
+export interface IconPropertyFieldProps {
+    value: IconReference | null | undefined;
+    onChange: (value: IconReference) => void;
+    catalog: EffectiveIconCatalog;
+    adapters?: IconAdapterRegistry;
+    allowed?: IconPickerAllowed;
+    readOnly?: boolean;
+    disabled?: boolean;
+    validationMessage?: string;
+    showMessage?: boolean;
+    invalid?: boolean;
+    strings: IconPropertyFieldStrings;
+    pickerLabels?: IconPickerLabels;
+    placement?: IconPickerPlacement;
+    id?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+}
+export declare function IconPropertyField({ value, onChange, catalog, adapters, allowed, readOnly, disabled, validationMessage, showMessage, invalid, strings, pickerLabels, placement, id, ...aria }: IconPropertyFieldProps): import("react").JSX.Element;

package/dist/screen-editor/Icons/IconPropertyFieldStrings.d.ts

@@ -0,0 +1,8 @@
+import { IconPickerLabels } from '@cratis/components/IconPicker';
+import { IconDiagnosticKind } from '@cratis/scene.engine';
+export interface IconPropertyFieldStrings {
+    ariaLabel: string;
+    picker: IconPickerLabels;
+    diagnostics: Record<IconDiagnosticKind, string>;
+    notAllowed: string;
+}

package/dist/screen-editor/Icons/IconValueProblem.d.ts

@@ -0,0 +1,7 @@
+import { IconDiagnostic } from '@cratis/scene.engine';
+import { IconReference } from '@cratis/scene.model';
+export interface IconValueProblem {
+    reference: IconReference;
+    diagnostic?: IconDiagnostic;
+    isNotAllowed: boolean;
+}

package/dist/screen-editor/Icons/UseIconPickerCatalogResult.d.ts

@@ -0,0 +1,7 @@
+import { IconPickerCatalog } from '@cratis/components/IconPicker';
+import { IconDiagnostic } from '@cratis/scene.engine';
+export interface UseIconPickerCatalogResult {
+    catalog: IconPickerCatalog;
+    diagnostics: IconDiagnostic[];
+    loadedVersion: number;
+}

package/dist/screen-editor/Icons/describeIconValueProblem.d.ts

@@ -0,0 +1,3 @@
+import { IconPropertyFieldStrings } from './IconPropertyFieldStrings';
+import { IconValueProblem } from './IconValueProblem';
+export declare function describeIconValueProblem(problem: IconValueProblem, strings: IconPropertyFieldStrings): string;

package/dist/screen-editor/Icons/diagnoseIconValue.d.ts

@@ -0,0 +1,5 @@
+import { IconPickerAllowed, IconPickerCatalog } from '@cratis/components/IconPicker';
+import { EffectiveIconCatalog } from '@cratis/scene.engine';
+import { IconReference } from '@cratis/scene.model';
+import { IconValueProblem } from './IconValueProblem';
+export declare function diagnoseIconValue(catalog: EffectiveIconCatalog, offered: IconPickerCatalog, value: IconReference | null | undefined, allowed?: IconPickerAllowed): IconValueProblem | undefined;

package/dist/screen-editor/Icons/effectiveIconCatalogOf.d.ts

@@ -0,0 +1,3 @@
+import { EffectiveIconCatalog } from '@cratis/scene.engine';
+import { ScenePackageBundle } from '@cratis/scene.react';
+export declare function effectiveIconCatalogOf(packages: string[], bundles: ScenePackageBundle[]): EffectiveIconCatalog;

package/dist/screen-editor/Icons/iconCatalogSourcesOf.d.ts

@@ -0,0 +1,3 @@
+import { IconCatalogSource } from '@cratis/scene.engine';
+import { ScenePackageBundle } from '@cratis/scene.react';
+export declare function iconCatalogSourcesOf(bundles: ScenePackageBundle[]): IconCatalogSource[];

package/dist/screen-editor/Icons/toIconPickerCatalog.d.ts

@@ -0,0 +1,5 @@
+import { IconPickerCatalog } from '@cratis/components/IconPicker';
+import { EffectiveIconCatalog, EffectiveIconEntry } from '@cratis/scene.engine';
+import { IconAdapterRegistry } from '@cratis/scene.react';
+import { IconPickerCatalogState } from './IconPickerCatalogState';
+export declare function toIconPickerCatalog(catalog: EffectiveIconCatalog, entries: EffectiveIconEntry[], adapters?: IconAdapterRegistry, state?: IconPickerCatalogState): IconPickerCatalog;

package/dist/screen-editor/Icons/useIconPickerCatalog.d.ts

@@ -0,0 +1,4 @@
+import { EffectiveIconCatalog } from '@cratis/scene.engine';
+import { IconAdapterRegistry } from '@cratis/scene.react';
+import { UseIconPickerCatalogResult } from './UseIconPickerCatalogResult';
+export declare function useIconPickerCatalog(catalog: EffectiveIconCatalog, adapters?: IconAdapterRegistry): UseIconPickerCatalogResult;

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

@@ -0,0 +1,7 @@
+import type { ActionPresentation } from './ActionPresentation';
+export interface ActionModel {
+    sliceId: string;
+    sliceName: string;
+    inputs: Record<string, string>;
+    presentation: ActionPresentation;
+}

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

@@ -0,0 +1,5 @@
+export declare enum ActionPresentation {
+    None = "none",
+    Modal = "modal",
+    Drawer = "drawer"
+}

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

@@ -0,0 +1,10 @@
+export interface StateChangeSlice {
+    id: string;
+    name: string;
+    origin: string[];
+    inputs: {
+        name: string;
+        type: string;
+        required: boolean;
+    }[];
+}

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

@@ -0,0 +1,8 @@
+import { type SceneEdit } from '@cratis/scene.model';
+import type { ActionModel } from './ActionModel';
+export declare const actionComponentName = "action";
+export declare const presentationProperty = "presentation";
+export declare const argumentsProperty = "arguments";
+export declare function readActionModel(properties: Record<string, unknown> | undefined, sliceName?: string): ActionModel | undefined;
+export declare function toActionProperties(model: ActionModel): Record<string, unknown>;
+export declare function actionEdits(componentId: string, model: ActionModel): SceneEdit[];

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

@@ -0,0 +1,14 @@
+import type { ActionModel } from './ActionModel';
+import type { StateChangeSlice } from './StateChangeSlice';
+export declare enum ActionProblemKind {
+    MissingSlice = "missingSlice",
+    UnmappedInput = "unmappedInput",
+    UnknownInput = "unknownInput",
+    UnknownSource = "unknownSource"
+}
+export interface ActionProblem {
+    kind: ActionProblemKind;
+    input?: string;
+}
+export declare function diagnoseAction(model: ActionModel, slices: readonly StateChangeSlice[], availableSources: ReadonlySet<string>): ActionProblem[];
+export declare function suggestInputs(slice: StateChangeSlice, sourceFor: (inputName: string) => string | undefined): Record<string, string>;

package/dist/screen-editor/ScreenEditor/Binding/availableSourcesFor.d.ts

@@ -0,0 +1,2 @@
+import type { QueryCandidate } from '@cratis/scene.model';
+export declare function availableSourcesFor(candidates: readonly QueryCandidate[]): Record<string, string>;

package/dist/screen-editor/ScreenEditor/Binding/bindingScopeTypes.d.ts

@@ -0,0 +1,2 @@
+import type { BindingTypeScope } from '@cratis/scene.engine';
+export declare function createBindingScope(types: Record<string, string>): BindingTypeScope;

package/dist/screen-editor/ScreenEditor/Binding/previewState.d.ts

@@ -0,0 +1,17 @@
+import type { QueryBinding, QueryCandidate } from '@cratis/scene.model';
+export declare enum PreviewState {
+    NoQuery = "noQuery",
+    MissingQuery = "missingQuery",
+    Loading = "loading",
+    Empty = "empty",
+    Error = "error",
+    Ready = "ready"
+}
+export interface PreviewInput {
+    binding?: QueryBinding;
+    candidate?: QueryCandidate;
+    isLoading: boolean;
+    error?: unknown;
+    rowCount?: number;
+}
+export declare function previewState({ binding, candidate, isLoading, error, rowCount }: PreviewInput): PreviewState;

package/dist/screen-editor/ScreenEditor/Binding/queryBindingModel.d.ts

@@ -0,0 +1,8 @@
+import type { QueryBinding, QueryCandidate, QueryParameter, QueryResultField } from '@cratis/scene.model';
+export declare function bindToCandidate(candidate: QueryCandidate): QueryBinding;
+export declare function isQueryBinding(value: unknown): value is QueryBinding;
+export declare function mapParameter(binding: QueryBinding, parameter: string, sourcePath: string): QueryBinding;
+export declare function mapColumn(binding: QueryBinding, field: string, target?: string): QueryBinding;
+export declare function unmapColumn(binding: QueryBinding, field: string): QueryBinding;
+export declare const sourceOf: (binding: QueryBinding, parameter: QueryParameter) => string;
+export declare const isColumnShown: (binding: QueryBinding, field: QueryResultField) => boolean;

package/dist/screen-editor/ScreenEditor/Binding/settleBinding.d.ts

@@ -0,0 +1,7 @@
+import type { PropertyDescriptor, QueryBinding, QueryCandidate, SceneDiagnostic } from '@cratis/scene.model';
+import { type BindingTypeScope } from '@cratis/scene.engine';
+export interface SettledBinding {
+    diagnostics: SceneDiagnostic[];
+    isStorable: boolean;
+}
+export declare function settleBinding(descriptor: PropertyDescriptor, candidate: QueryCandidate | undefined, binding: QueryBinding, scope: BindingTypeScope): SettledBinding;

package/dist/screen-editor/ScreenEditor/Binding/toSceneCandidates.d.ts

@@ -0,0 +1,22 @@
+import { type QueryCandidate as SceneQueryCandidate } from '@cratis/scene.model';
+export interface DiscoveredQueryCandidate {
+    id: string;
+    name: string;
+    origin: {
+        kind: string;
+        id: string;
+        name: string;
+    }[];
+    parameters: {
+        name: string;
+        type: string;
+        required: boolean;
+    }[];
+    resultShape: string;
+    resultFields: {
+        name: string;
+        type: string;
+        isIdentity?: boolean;
+    }[];
+}
+export declare function toSceneCandidates(candidates: readonly DiscoveredQueryCandidate[]): SceneQueryCandidate[];

package/dist/screen-editor/ScreenEditor/Collections/orderedItems.d.ts

@@ -0,0 +1,11 @@
+import { type InspectedProperty, type SceneEdit } from '@cratis/scene.model';
+import type { OrderedItem, OrderedItemCapabilities, OrderedItemProposal } from '@cratis/components/ConfigurationEditor';
+export interface SceneOrderedItem extends OrderedItem {
+    values: Record<string, unknown>;
+}
+export declare function toOrderedItems(property: InspectedProperty): {
+    items: SceneOrderedItem[];
+    fixed: SceneOrderedItem[];
+};
+export declare function toCapabilities(property: InspectedProperty): OrderedItemCapabilities;
+export declare function proposalToEdits(componentId: string, property: InspectedProperty, proposal: OrderedItemProposal<SceneOrderedItem>): SceneEdit[];

package/dist/screen-editor/ScreenEditor/Defaults/defaultLayoutIcons.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutIcons } from '../Layouts/toLayoutContainerDescriptors';
+export declare const defaultLayoutIcons: LayoutIcons;

package/dist/screen-editor/ScreenEditor/Defaults/defaultLayoutLabels.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutLabels } from '../Layouts/toLayoutContainerDescriptors';
+export declare const defaultLayoutLabels: LayoutLabels;

package/dist/screen-editor/ScreenEditor/Defaults/defaultPaletteIcons.d.ts

@@ -0,0 +1,2 @@
+import type { PaletteIcons } from '../Palette/buildPalette';
+export declare const defaultPaletteIcons: PaletteIcons;

package/dist/screen-editor/ScreenEditor/Defaults/defaultPaletteSources.d.ts

@@ -0,0 +1,2 @@
+import type { PaletteSource } from '../Palette/buildPalette';
+export declare const defaultPaletteSources: readonly PaletteSource[];

package/dist/screen-editor/ScreenEditor/Defaults/defaultScreenEditorStrings.d.ts

@@ -0,0 +1,2 @@
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+export declare const defaultScreenEditorStrings: ScreenEditorStrings;

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

@@ -0,0 +1,2 @@
+import type { ExternalComponent, SceneElement } from '@cratis/scene.model';
+export declare function createExternalComponent(id: string, name: string, componentName: string, properties?: Record<string, unknown>, slots?: Record<string, SceneElement[]>): ExternalComponent;

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

@@ -0,0 +1,6 @@
+import { type Panel, type SceneElement } from '@cratis/scene.model';
+import { LayoutItem } from '../Layouts/LayoutItem';
+export declare function createPanel(item: LayoutItem, id: string, name: string, children?: SceneElement[], extent?: {
+    width?: number;
+    height?: number;
+}): Panel;

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

@@ -0,0 +1,21 @@
+import { HorizontalAlignment, Visibility, VerticalAlignment } from '@cratis/scene.model';
+export declare function frameworkElement(id: string, name: string): {
+    id: string;
+    name: string;
+    visibility: Visibility;
+    isEnabled: boolean;
+    opacity: number;
+    size: {};
+    zIndex: number;
+    minimumSize: {};
+    maximumSize: {};
+    margin: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    horizontalAlignment: HorizontalAlignment;
+    verticalAlignment: VerticalAlignment;
+    properties: Record<string, unknown>;
+};

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

@@ -0,0 +1,15 @@
+import type { SceneDocument } from '@cratis/scene.model';
+export declare enum SceneDocumentProblem {
+    NotJson = "notJson",
+    WrongShape = "wrongShape",
+    MissingScreen = "missingScreen",
+    MissingTemplate = "missingTemplate"
+}
+export type ReadSceneDocument = {
+    readable: true;
+    document: SceneDocument;
+} | {
+    readable: false;
+    problem: SceneDocumentProblem;
+};
+export declare function readSceneDocument(stored: unknown, authoringTemplate?: string): ReadSceneDocument;

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

@@ -0,0 +1,10 @@
+import { type EditingScope, type Layout, type Panel, type SceneDocument, type SceneElement } from '@cratis/scene.model';
+export declare const studioLayout: Layout;
+export declare const contentSlot = "content";
+export declare const screenName = "Screen";
+export declare const templateRootId = "template-root";
+export declare const screenRootId = "screen-root";
+export declare function createScreenDocument(root: SceneElement, template?: string): SceneDocument;
+export declare function createTemplateDocument(name: string, root: SceneElement, fitsSlot?: string): SceneDocument;
+export declare function authoredRoot(document: SceneDocument, template?: string): Panel | undefined;
+export declare function editingScope(template?: string, authoringTemplate?: boolean): EditingScope;

package/dist/screen-editor/ScreenEditor/DropRegions/DropRegion.d.ts

@@ -0,0 +1,12 @@
+import type { DropRegionKind } from './DropRegionKind';
+import type { InsertionAxis } from './InsertionAxis';
+export interface DropRegion {
+    id: string;
+    kind: DropRegionKind;
+    containerId: string | null;
+    index: number;
+    axis: InsertionAxis;
+    isEmptyContainer: boolean;
+    afterId?: string;
+    beforeId?: string;
+}

package/dist/screen-editor/ScreenEditor/DropRegions/DropRegionKind.d.ts

@@ -0,0 +1,4 @@
+export declare enum DropRegionKind {
+    Container = "container",
+    Between = "between"
+}

package/dist/screen-editor/ScreenEditor/DropRegions/InsertionAxis.d.ts

@@ -0,0 +1,5 @@
+export declare enum InsertionAxis {
+    Horizontal = "horizontal",
+    Vertical = "vertical",
+    None = "none"
+}

package/dist/screen-editor/ScreenEditor/DropRegions/computeDropRegions.d.ts

@@ -0,0 +1,6 @@
+import { LayoutArrangement } from '@cratis/scene/ScreenEditor';
+import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
+import type { DropRegion } from './DropRegion';
+import { InsertionAxis } from './InsertionAxis';
+export declare function insertionAxisFor(arrangement: LayoutArrangement | undefined): InsertionAxis;
+export declare function computeDropRegions<T>(roots: T[], surfaceArrangement: LayoutArrangement, adapter: StructureTreeAdapter<T>): DropRegion[];

package/dist/screen-editor/ScreenEditor/Exposure/exposureEdits.d.ts

@@ -0,0 +1,10 @@
+import { CollectionOperation, type ExposePropertyEdit, type SceneDocument, type UnexposePropertyEdit } from '@cratis/scene.model';
+export interface ExposureChoice {
+    label?: string;
+    operations?: CollectionOperation[];
+    editableFields?: string[];
+}
+export declare function exposePropertyEdit(templateName: string, componentId: string, path: string, choice?: ExposureChoice): ExposePropertyEdit;
+export declare function unexposePropertyEdit(templateName: string, componentId: string, path: string): UnexposePropertyEdit;
+export declare const isExposed: (document: SceneDocument, templateName: string, componentId: string, path: string) => boolean;
+export declare const defaultCollectionOperations: CollectionOperation[];

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

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+export interface DefaultPaletteHostProps {
+    placement: 'floating' | 'inline';
+    children: ReactNode;
+}
+export declare const DefaultPaletteHost: ({ placement, children }: DefaultPaletteHostProps) => import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+export interface ScreenEditorBoundaryProps {
+    strings: ScreenEditorStrings;
+    onClose?: () => void;
+    children: ReactNode;
+}
+export declare const ScreenEditorBoundary: ({ strings, onClose, children }: ScreenEditorBoundaryProps) => import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+import type { ScreenEditorEnvironment } from './ScreenEditorHost';
+export interface ScreenEditorControlProvidersProps {
+    environment: ScreenEditorEnvironment;
+    children: ReactNode;
+}
+export declare const ScreenEditorControlProviders: ({ environment, children }: ScreenEditorControlProvidersProps) => import("react").JSX.Element;

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

@@ -0,0 +1,41 @@
+import type { NodeInspection, SceneDiagnostic, SceneDocument, SceneEdit, SceneElement } from '@cratis/scene.model';
+import type { EditingContext } from '@cratis/scene.engine';
+import type { Ownership } from '../Structure/Ownership';
+import type { StructureEdit } from '../Structure/StructureEdit';
+import type { StructureEditRejection } from '../Structure/StructureEditRejection';
+import type { StructureTreeAdapter } from '../Structure/StructureTreeAdapter';
+import type { EditorComposition } from '../Templates/composeEditorScreen';
+import type { DropRegion } from '../DropRegions/DropRegion';
+import type { LayoutItem } from '../Layouts/LayoutItem';
+export interface ScreenEditorController {
+    document: SceneDocument;
+    composition: EditorComposition;
+    context: EditingContext;
+    selectedId?: string;
+    selection?: SceneElement;
+    inspection?: NodeInspection;
+    diagnostics: readonly SceneDiagnostic[];
+    adapter: StructureTreeAdapter<SceneElement>;
+    ownershipOf: (elementId: string) => Ownership;
+    dropRegions: readonly DropRegion[];
+    select: (elementId: string | undefined) => void;
+    apply: (edit: SceneEdit, label: string) => void;
+    tryApply: (edit: SceneEdit, label: string) => {
+        applied: boolean;
+        diagnostics: SceneDiagnostic[];
+    };
+    applyAll: (edits: SceneEdit[], label: string) => {
+        applied: boolean;
+        diagnostics: SceneDiagnostic[];
+    };
+    move: (edit: StructureEdit) => StructureEditRejection | undefined;
+    insertComponent: (componentName: string, parentId: string | undefined, index: number | undefined) => void;
+    insertLayout: (item: LayoutItem, parentId: string | undefined, index: number | undefined) => void;
+    remove: (elementId: string) => void;
+    setProperty: (property: NodeInspection['properties'][number], value: unknown) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    isDirty: boolean;
+}

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

@@ -0,0 +1,5 @@
+import type { FileUploadHandler } from '@cratis/scene.primereact';
+export interface ScreenEditorFileUpload {
+    handler?: FileUploadHandler;
+    allowedOrigins?: readonly string[];
+}

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

@@ -0,0 +1,36 @@
+import type { SceneDocument } from '@cratis/scene.model';
+import type { QueryCandidate } from '@cratis/scene.model';
+import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+import type { QuillLoader } from '@cratis/scene.primereact';
+import type { StateChangeSlice } from '../Actions/StateChangeSlice';
+import type { ScreenEditorFileUpload } from './ScreenEditorFileUpload';
+export interface ScreenEditorSubject {
+    documentText?: string;
+    document?: SceneDocument;
+    windowSize?: {
+        width: number;
+        height: number;
+    };
+    authoringTemplate?: string;
+    screenTemplate?: string;
+}
+export interface ScreenEditorEnvironment {
+    runtime: ScreenEditorRuntime;
+    queryCandidates: readonly QueryCandidate[];
+    stateChangeSlices: readonly StateChangeSlice[];
+    destinations: readonly ConfigurationDestination[];
+    availableSources: Record<string, string>;
+    richText?: QuillLoader;
+    fileUpload?: ScreenEditorFileUpload;
+}
+export interface ScreenEditorResult {
+    document: SceneDocument;
+    legacyElements: unknown[];
+    windowSize: {
+        width: number;
+        height: number;
+    };
+    layout: number;
+    changed: boolean;
+}

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

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import { type PaletteIcons, type PaletteSource } from '../Palette/buildPalette';
+import type { LayoutLabels } from '../Layouts/toLayoutContainerDescriptors';
+import type { ScreenEditorEnvironment, ScreenEditorResult, ScreenEditorSubject } from './ScreenEditorHost';
+export interface ScreenEditorOverlayProps {
+    subject: ScreenEditorSubject;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    layoutLabels: LayoutLabels;
+    icons: PaletteIcons;
+    paletteSources: readonly PaletteSource[];
+    sourceRect: DOMRect;
+    initialSize?: {
+        width: number;
+        height: number;
+    };
+    centerOffsetX?: number;
+    renderPaletteHost?: (palette: ReactNode) => ReactNode;
+    onClose: (result: ScreenEditorResult) => void;
+    onBeforeClose?: (result: ScreenEditorResult) => Promise<string | undefined>;
+    onDismiss?: () => void;
+}
+export declare const ScreenEditorOverlay: (props: ScreenEditorOverlayProps) => import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+import { PrimeReactProvider } from '@primereact/core/config';
+export type ScreenEditorPrimeReactProviderProps = NonNullable<Parameters<typeof PrimeReactProvider>[0]>;
+export declare const ScreenEditorPrimeReactProvider: (props: ScreenEditorPrimeReactProviderProps) => import("react").JSX.Element;