@cratis/event-models 0.312.1 → 0.313.0

package/dist/screen-editor/ScreenEditor/Drafting/SceneScreenDraft.d.ts

@@ -0,0 +1,30 @@
+import type { EditingContext } from '@cratis/scene.engine';
+import type { SceneDocument, SceneEdit } from '@cratis/scene.model';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+export interface SceneScreenDraftAgent {
+    readonly context: string;
+    readonly parameterlessQueryIds: readonly string[];
+    generate(request: SceneScreenDraftRequest, signal: AbortSignal): Promise<string>;
+}
+export interface SceneScreenDraftRequest {
+    instruction: string;
+    catalogue: string;
+    document: string;
+}
+export interface PreparedSceneScreenDraft {
+    readonly base: SceneDocument;
+    readonly document: SceneDocument;
+    readonly answer: string;
+    readonly reply: string;
+    readonly edits: SceneEdit[];
+    readonly parameterlessQueryIds: readonly string[];
+    readonly runtime: ScreenEditorRuntime;
+    readonly context: EditingContext;
+}
+export type SceneScreenDraftPreparation = {
+    prepared: PreparedSceneScreenDraft;
+    problem?: never;
+} | {
+    problem: string;
+    prepared?: never;
+};

package/dist/screen-editor/ScreenEditor/Drafting/SceneScreenDraftReview.d.ts

@@ -0,0 +1,14 @@
+import { type SceneDocument } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { SceneScreenDraftAgent } from './SceneScreenDraft';
+import type { SceneScreenDraftStrings } from './SceneScreenDraftStrings';
+export interface SceneScreenDraftReviewProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    agent: SceneScreenDraftAgent;
+    onPreview?: (document: SceneDocument) => void;
+    strings?: SceneScreenDraftStrings;
+    previewing?: boolean;
+}
+export declare function SceneScreenDraftReview({ controller, environment, agent, onPreview, strings: text, previewing }: SceneScreenDraftReviewProps): import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Drafting/SceneScreenDraftStrings.d.ts

@@ -0,0 +1,21 @@
+export interface SceneScreenDraftStrings {
+    open: string;
+    title: string;
+    discard: string;
+    discardAriaLabel: string;
+    preview: string;
+    apply: string;
+    explanation: string;
+    instruction: string;
+    generate: string;
+    generating: string;
+    status: string;
+    review: string;
+    additions: string;
+    addControl: (target: string) => string;
+    setProperty: (path: string, node: string) => string;
+    changed: string;
+    generationFailed: string;
+    applyFailed: string;
+    undoLabel: string;
+}

package/dist/screen-editor/ScreenEditor/Drafting/SceneScreenDraftToolbar.d.ts

@@ -0,0 +1,16 @@
+import type { SceneDocument } from '@cratis/scene.model';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import type { SceneScreenDraftAgent } from './SceneScreenDraft';
+export interface SceneScreenDraftToolbarProps {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    agent?: SceneScreenDraftAgent;
+    readOnly: boolean;
+    authoringTemplate?: string;
+    onPreview?: (document: SceneDocument) => void;
+    previewing?: boolean;
+}
+export declare const SceneScreenDraftToolbar: ({ controller, environment, strings, agent, readOnly, authoringTemplate, onPreview, previewing }: SceneScreenDraftToolbarProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/Drafting/defaultSceneScreenDraftStrings.d.ts

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

package/dist/screen-editor/ScreenEditor/Drafting/prepareSceneScreenDraft.d.ts

@@ -0,0 +1,10 @@
+import { type EditingContext } from '@cratis/scene.engine';
+import { type SceneDocument } from '@cratis/scene.model';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+import type { SceneScreenDraftPreparation } from './SceneScreenDraft';
+export interface SceneScreenDraftScope {
+    runtime: ScreenEditorRuntime;
+    context: EditingContext;
+    parameterlessQueryIds: readonly string[];
+}
+export declare function prepareSceneScreenDraft(base: SceneDocument, answer: string, scope: SceneScreenDraftScope): SceneScreenDraftPreparation;

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftElement.d.ts

@@ -0,0 +1,3 @@
+import type { SceneElement } from '@cratis/scene.model';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+export declare function insertionElement(value: unknown, runtime: ScreenEditorRuntime): SceneElement;

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftEnvelope.d.ts

@@ -0,0 +1,5 @@
+export interface DraftEnvelope {
+    reply: string;
+    edits: unknown[];
+}
+export declare function readDraftEnvelope(envelope: unknown): DraftEnvelope;

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftInsertion.d.ts

@@ -0,0 +1,4 @@
+import { type SceneEdit } from '@cratis/scene.model';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+import type { DraftState } from './sceneScreenDraftState';
+export declare function insertEdit(raw: Record<string, unknown>, state: DraftState, runtime: ScreenEditorRuntime): SceneEdit;

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftProperty.d.ts

@@ -0,0 +1,4 @@
+import { type EditingContext } from '@cratis/scene.engine';
+import { type SceneEdit } from '@cratis/scene.model';
+import type { DraftState } from './sceneScreenDraftState';
+export declare function propertyEdit(raw: Record<string, unknown>, state: DraftState, context: EditingContext): SceneEdit;

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftRequest.d.ts

@@ -0,0 +1,6 @@
+import { type PropertyDescriptor, type SceneDocument } from '@cratis/scene.model';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+import type { SceneScreenDraftRequest } from './SceneScreenDraft';
+export declare const supportedDraftProperty: (property: PropertyDescriptor) => boolean;
+export declare const supportedDraftComponents: (runtime: ScreenEditorRuntime) => import("@cratis/scene.model").ComponentDescriptor[];
+export declare function sceneScreenDraftRequest(instruction: string, document: SceneDocument, runtime: ScreenEditorRuntime): SceneScreenDraftRequest;

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftReviewVisibility.d.ts

@@ -0,0 +1 @@
+export declare const sceneScreenDraftReviewVisible: (open: boolean, previewing: boolean) => boolean;

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftSession.d.ts

@@ -0,0 +1,16 @@
+import type { EditingContext } from '@cratis/scene.engine';
+import type { ScreenEditorRuntime } from '../Runtime/screenEditorRuntime';
+import type { SessionCell } from '../Session/SessionCell';
+import type { PreparedSceneScreenDraft } from './SceneScreenDraft';
+import type { SceneScreenDraftStrings } from './SceneScreenDraftStrings';
+export declare function sceneScreenDraftSession(cell: SessionCell, runtime: ScreenEditorRuntime, context: EditingContext, text?: SceneScreenDraftStrings): {
+    isSceneScreenDraftCurrent: (draft: PreparedSceneScreenDraft) => boolean;
+    prepareSceneScreenDraft: (answer: string, parameterlessQueryIds: readonly string[]) => import("./SceneScreenDraft").SceneScreenDraftPreparation;
+    applySceneScreenDraft: (draft: PreparedSceneScreenDraft) => {
+        applied: boolean;
+        problem: string;
+    } | {
+        problem?: undefined;
+        applied: boolean;
+    };
+};

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftState.d.ts

@@ -0,0 +1,6 @@
+import type { SceneDocument } from '@cratis/scene.model';
+export interface DraftState {
+    document: SceneDocument;
+    readonly used: Set<string>;
+    readonly added: Set<string>;
+}

package/dist/screen-editor/ScreenEditor/Drafting/sceneScreenDraftValues.d.ts

@@ -0,0 +1,5 @@
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const hasOnlyKeys: (value: Record<string, unknown>, allowed: string[]) => boolean;
+export declare function sameValue(left: unknown, right: unknown): boolean;
+export declare function checkTree(value: unknown, depth?: number): void;
+export declare function collectIdentities(value: unknown, found?: Set<string>): Set<string>;

package/dist/screen-editor/ScreenEditor/Drafting/useSceneScreenDraft.d.ts

@@ -0,0 +1,21 @@
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { PreparedSceneScreenDraft, SceneScreenDraftAgent } from './SceneScreenDraft';
+import type { SceneScreenDraftStrings } from './SceneScreenDraftStrings';
+export declare function createSceneScreenDraftRequestGate(): {
+    start: () => AbortController | undefined;
+    current: (request: AbortController) => boolean;
+    finish: (request: AbortController) => void;
+    invalidate: () => void;
+};
+export declare function useSceneScreenDraft(controller: ScreenEditorController, environment: ScreenEditorEnvironment, agent: SceneScreenDraftAgent, text?: SceneScreenDraftStrings): {
+    instruction: string;
+    setInstruction: (value: string) => void;
+    prepared: PreparedSceneScreenDraft | undefined;
+    problem: string | undefined;
+    busy: boolean;
+    generate: () => Promise<void>;
+    preview: () => import("@cratis/scene.model").SceneDocument | undefined;
+    apply: () => boolean;
+    discard: () => void;
+};

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

@@ -1,4 +1,5 @@
 import type { CanvasPlacement } from '../Document/placeOnCanvas';
+import type { PreparedSceneScreenDraft, SceneScreenDraftPreparation } from '../Drafting/SceneScreenDraft';
 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';
@@ -26,6 +27,12 @@ export interface ScreenEditorController {
     selectedItemId: string | undefined;
     selectItem: (componentId: string | undefined, itemId: string | undefined) => void;
     document: SceneDocument;
+    prepareSceneScreenDraft?: (answer: string, parameterlessQueryIds: readonly string[]) => SceneScreenDraftPreparation;
+    applySceneScreenDraft?: (draft: PreparedSceneScreenDraft) => {
+        applied: boolean;
+        problem?: string;
+    };
+    isSceneScreenDraftCurrent?: (draft: PreparedSceneScreenDraft) => boolean;
     composition: EditorComposition;
     context: EditingContext;
     selectedId?: string;

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

@@ -5,6 +5,7 @@ import type { PaletteIcons, PaletteSource } from '../Palette/buildPalette';
 import type { LayoutLabels } from '../Layouts/toLayoutContainerDescriptors';
 import type { ScreenEditorEnvironment, ScreenEditorResult, ScreenEditorSubject } from './ScreenEditorHost';
 import { type WindowSizeMemory } from '../Viewport/windowSizeMemory';
+import type { SceneScreenDraftAgent } from '../Drafting/SceneScreenDraft';
 export interface ScreenEditorOverlayProps {
     subject: ScreenEditorSubject;
     environment: ScreenEditorEnvironment;
@@ -25,6 +26,8 @@ export interface ScreenEditorOverlayProps {
     onBeforeClose?: (result: ScreenEditorResult) => Promise<string | undefined>;
     onDismiss?: () => void;
     onPreview?: (document: SceneDocument) => void;
+    previewing?: boolean;
     readOnly?: boolean;
+    draftAgent?: SceneScreenDraftAgent;
 }
 export declare const ScreenEditorOverlay: (props: ScreenEditorOverlayProps) => import("react").JSX.Element;

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

@@ -32,5 +32,6 @@ export interface ScreenEditorWindowProps {
     onDiscard?: () => void;
     onPreview?: (document: SceneDocument) => void;
     readOnly?: boolean;
+    toolbarActions?: ReactNode;
 }
-export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, authoringTemplate, title, deviceFrame, saveFailure, onKeepEditing, onDiscard, onPreview, readOnly }: ScreenEditorWindowProps) => import("react").JSX.Element;
+export declare const ScreenEditorWindow: ({ controller, environment, strings, window: state, authoringTemplate, title, deviceFrame, saveFailure, onKeepEditing, onDiscard, onPreview, readOnly, toolbarActions }: ScreenEditorWindowProps) => import("react").JSX.Element;

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

@@ -1,3 +1,4 @@
+import type { SceneScreenDraftStrings } from '../Drafting/SceneScreenDraftStrings';
 import type { IconPickerLabels } from '@cratis/components/IconPicker';
 import type { IconPropertyFieldStrings } from '../../Icons/IconPropertyFieldStrings';
 import type { ComponentPickerStrings } from '../Palette/ComponentPicker';
@@ -288,6 +289,7 @@ export interface ScreenEditorStrings {
             };
         };
     };
+    draft?: SceneScreenDraftStrings;
     structureLabel: string;
     structureEmpty: string;
     moveUp: string;

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

@@ -1,3 +1,4 @@
+export * from './Drafting/SceneScreenDraft';
 export * from './Host/ScreenEditorOverlay';
 export * from './Host/ScreenEditorPrimeReactProvider';
 export * from './Host/screenEditorPrimeReactDefaults';