@cratis/event-models 0.180.0 → 0.181.0

package/dist/screen-editor/CascadeMenu/CascadeEntry.d.ts

@@ -0,0 +1,44 @@
+import { CascadeEntryKind } from './CascadeEntryKind';
+/** A further action on a row, offered beside it - for example copying a blueprint template into the user's own. */
+export interface CascadeSecondaryAction {
+    /** What the action is called. */
+    label: string;
+    /** Called when the action is chosen. The menu stays open unless `closes` is set. */
+    onActivate: () => void;
+    /** Whether the menu closes after the action. */
+    closes?: boolean;
+}
+/** A heading, subheading, separator or note: a row with a label and nothing to choose. */
+export interface CascadeStaticEntry {
+    kind: CascadeEntryKind.Heading | CascadeEntryKind.Subheading | CascadeEntryKind.Separator | CascadeEntryKind.Note;
+    id: string;
+    label: string;
+}
+/** A row that does something when chosen. */
+export interface CascadeItemEntry {
+    kind: CascadeEntryKind.Item;
+    id: string;
+    label: string;
+    /** Text aligned to the right of the row, such as a locale. */
+    trailing?: string;
+    /** A line under the label. */
+    description?: string;
+    /** Whether this is the current choice: it shows a check and the highlighted row. */
+    checked?: boolean;
+    /** Why the row cannot be chosen, when it cannot. */
+    disabledReason?: string;
+    /** Further actions offered beside the row, in order. */
+    actions?: CascadeSecondaryAction[];
+    /** Called when the row is chosen. The menu closes afterwards. */
+    onActivate: () => void;
+}
+/** A row that opens a further panel. */
+export interface CascadeSubmenuEntry {
+    kind: CascadeEntryKind.Submenu;
+    id: string;
+    label: string;
+    /** The rows of the panel it opens. */
+    entries: CascadeEntry[];
+}
+/** One row of a cascading menu. */
+export type CascadeEntry = CascadeStaticEntry | CascadeItemEntry | CascadeSubmenuEntry;

package/dist/screen-editor/CascadeMenu/CascadeEntryKind.d.ts

@@ -0,0 +1,15 @@
+/** What a row of a cascading menu is. */
+export declare enum CascadeEntryKind {
+    /** A small-caps heading over the rows below it. */
+    Heading = "heading",
+    /** A sentence-case heading nested under a heading, such as a category. */
+    Subheading = "subheading",
+    /** A row that does something when chosen. */
+    Item = "item",
+    /** A row that opens a further panel beside the menu. */
+    Submenu = "submenu",
+    /** A thin rule between groups. */
+    Separator = "separator",
+    /** A line of explanation that cannot be chosen. */
+    Note = "note"
+}

package/dist/screen-editor/CascadeMenu/CascadeFilter.d.ts

@@ -0,0 +1,9 @@
+/** The filter field at the top of a cascading menu. */
+export interface CascadeFilter {
+    /** What has been typed. */
+    value: string;
+    /** The field's placeholder, which is also its accessible name. */
+    placeholder: string;
+    /** Called as the text changes. */
+    onChange: (value: string) => void;
+}

package/dist/screen-editor/CascadeMenu/CascadeMenu.d.ts

@@ -0,0 +1,25 @@
+import { CascadeEntry } from './CascadeEntry';
+import { CascadeFilter } from './CascadeFilter';
+export interface CascadeMenuProps {
+    /** Where the menu opens: the control that was pressed. */
+    anchor: DOMRect;
+    /** The control that opened the menu. Pressing it again is its own to handle, so it does not count as clicking elsewhere. */
+    trigger?: HTMLElement | null;
+    /** The rows of the first panel. */
+    entries: CascadeEntry[];
+    /** The accessible name of the menu. */
+    label: string;
+    /** The filter field at the top of the first panel, when there is one. */
+    filter?: CascadeFilter;
+    /** Called when the menu should go away: a row was chosen, the user pressed elsewhere or pressed Escape. */
+    onClose: () => void;
+}
+/**
+ * A cascading menu: a first panel whose rows may open further panels beside it, the way a desktop menu does.
+ *
+ * It is the one menu Studio draws for choosing among own things and blueprint things - templates and sample data -
+ * so the structure (own first, blueprints one level deeper) and the keyboard behaviour exist once. It is drawn on the
+ * page, not inside the region it belongs to, so nothing clips it; arrow keys move through rows, the right arrow opens a
+ * submenu and the left arrow or Escape closes it, Tab stays inside the menu, and focus returns to what opened it.
+ */
+export declare const CascadeMenu: ({ anchor, trigger, entries, label, filter, onClose }: CascadeMenuProps) => import("react").ReactPortal;

package/dist/screen-editor/CascadeMenu/CascadePanel.d.ts

@@ -0,0 +1,26 @@
+import { CascadeEntry } from './CascadeEntry';
+import { CascadeFilter } from './CascadeFilter';
+import { OpenSubmenu } from './OpenSubmenu';
+import { type PanelRect } from './placeCascadePanel';
+export interface CascadePanelProps {
+    /** The rows of the panel. */
+    entries: CascadeEntry[];
+    /** How deep the panel is: 0 for the first. */
+    depth: number;
+    /** Where the panel opens: the control that opened the menu for the first panel, the opening row for the rest. */
+    anchor: PanelRect;
+    /** The submenus open at this moment, outermost first. */
+    openPath: OpenSubmenu[];
+    /** The accessible name of the panel. */
+    label: string;
+    /** The filter field, on the first panel only. */
+    filter?: CascadeFilter;
+    /** Opens a submenu from a row. */
+    onOpen: (depth: number, submenu: OpenSubmenu) => void;
+    /** Closes every submenu from `depth` inward. */
+    onCollapse: (depth: number) => void;
+    /** Called when something was chosen. */
+    onChosen: () => void;
+}
+/** One panel of a cascading menu: headings, rows, and the rows that open the next panel. */
+export declare const CascadePanel: ({ entries, depth, anchor, openPath, label, filter, onOpen, onCollapse, onChosen }: CascadePanelProps) => import("react").JSX.Element;

package/dist/screen-editor/CascadeMenu/OpenSubmenu.d.ts

@@ -0,0 +1,8 @@
+import type { PanelRect } from './placeCascadePanel';
+/** A submenu that is open, and the row it opened from. */
+export interface OpenSubmenu {
+    /** The identifier of the row that opened it. */
+    id: string;
+    /** Where that row is, which the panel is placed beside. */
+    rect: PanelRect;
+}

package/dist/screen-editor/CascadeMenu/cascadeNavigation.d.ts

@@ -0,0 +1,27 @@
+/** The key a cascading menu reacts to, as a direction through its rows or across its panels. */
+export declare enum CascadeStep {
+    Previous = "previous",
+    Next = "next",
+    First = "first",
+    Last = "last",
+    Into = "into",
+    Out = "out"
+}
+/**
+ * What a key press means to a cascading menu, or `undefined` when the menu leaves it alone.
+ *
+ * @param key The pressed key.
+ * @param isTextField Whether focus is in a text field, which keeps the arrow keys that move its caret.
+ * @returns The step.
+ */
+export declare function stepForKey(key: string, isTextField: boolean): CascadeStep | undefined;
+/**
+ * Where focus lands after a step through a panel's rows. Moving past either end wraps round, so a keyboard user can
+ * never be left on a row with nowhere to go.
+ *
+ * @param step The step through the rows - `Previous`, `Next`, `First` or `Last`.
+ * @param current The row that has focus, or -1 when none does.
+ * @param count How many rows can take focus.
+ * @returns The index to focus, or -1 when there are no rows.
+ */
+export declare function focusTarget(step: CascadeStep, current: number, count: number): number;

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

@@ -0,0 +1,6 @@
+export * from './CascadeEntryKind';
+export * from './CascadeEntry';
+export * from './CascadeFilter';
+export * from './CascadeMenu';
+export * from './cascadeNavigation';
+export * from './placeCascadePanel';

package/dist/screen-editor/CascadeMenu/keepInputInMenu.d.ts

@@ -0,0 +1,18 @@
+import type { SyntheticEvent } from 'react';
+declare const keepInput: (event: SyntheticEvent) => void;
+/** Every way a user reaches into a menu. Spread it on the menu's outermost element, inside the portal. */
+export declare const menuInputBoundary: {
+    readonly onPointerDown: typeof keepInput;
+    readonly onPointerUp: typeof keepInput;
+    readonly onMouseDown: typeof keepInput;
+    readonly onMouseUp: typeof keepInput;
+    readonly onClick: typeof keepInput;
+    readonly onDoubleClick: typeof keepInput;
+    readonly onContextMenu: typeof keepInput;
+    readonly onWheel: typeof keepInput;
+    readonly onKeyUp: typeof keepInput;
+    readonly onDragStart: typeof keepInput;
+};
+/** Ends React's bubbling of a key press, for the one handler that needs to see it first. */
+export declare const keepKeyInMenu: typeof keepInput;
+export {};

package/dist/screen-editor/CascadeMenu/placeCascadePanel.d.ts

@@ -0,0 +1,37 @@
+/** A rectangle in viewport coordinates. */
+export interface PanelRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+/** The size of the viewport. */
+export interface PanelBounds {
+    width: number;
+    height: number;
+}
+/** Where a panel is fixed, in viewport coordinates. */
+export interface PanelPosition {
+    top: number;
+    left: number;
+}
+/**
+ * Places the first panel of a menu under (or, with no room, over) the control that opened it, aligned to its left
+ * edge, and keeps it inside the viewport.
+ *
+ * @param anchor The control's rectangle.
+ * @param size The panel's size once laid out.
+ * @param bounds The viewport.
+ * @returns The position.
+ */
+export declare function placePanelBelow(anchor: PanelRect, size: Pick<PanelRect, 'width' | 'height'>, bounds: PanelBounds): PanelPosition;
+/**
+ * Places a submenu panel beside the row that opened it: to the right when there is room, otherwise to the left, with
+ * its top level with the row and pulled up when it would run off the bottom.
+ *
+ * @param row The row's rectangle.
+ * @param size The panel's size once laid out.
+ * @param bounds The viewport.
+ * @returns The position.
+ */
+export declare function placePanelBeside(row: PanelRect, size: Pick<PanelRect, 'width' | 'height'>, bounds: PanelBounds): PanelPosition;

package/dist/screen-editor/{ColumnListEditor-Cku6GGLp.js → ColumnListEditor-BHLrr4WK.js}

@@ -1,5 +1,5 @@
 import { l as m, o as _, v as N, y } from "./structuredValue-vqCZttsk.js";
-import { FieldEditor as C } from "./FieldEditor-SquvComm.js";
+import { FieldEditor as C } from "./FieldEditor-4a_4uQit.js";
 import { jsx as a, jsxs as u } from "react/jsx-runtime";
 var p = [
   "start",

package/dist/screen-editor/{FieldEditor-SquvComm.js → FieldEditor-4a_4uQit.js}

@@ -1,4 +1,4 @@
-import { t as y } from "./SearchableSelect-WUNlC3tk.js";
+import { t as y } from "./SearchableSelect-C4yzIyo_.js";
 import { Fragment as h, jsx as d, jsxs as v } from "react/jsx-runtime";
 function g(n) {
   const e = n.toLowerCase().replace(/[?[\]]/g, "");

package/dist/screen-editor/{FieldListEditor-CNxskXPf.js → FieldListEditor-RGb59BLM.js}

@@ -1,5 +1,5 @@
 import { l as c, t as g, v as w, y as m } from "./structuredValue-vqCZttsk.js";
-import { FieldEditor as y } from "./FieldEditor-SquvComm.js";
+import { FieldEditor as y } from "./FieldEditor-4a_4uQit.js";
 import { jsx as r, jsxs as u } from "react/jsx-runtime";
 var $ = ({ value: p, onChange: b, descriptor: h, context: l, disabled: a, problem: v, id: d }) => {
   const s = l.strings.editors.list, o = g(p).filter((i) => typeof i == "string"), e = (i) => b(i.length === 0 ? void 0 : i), f = {

package/dist/screen-editor/NavigationItemTargetEditor-C3epn45p.js

@@ -0,0 +1,72 @@
+import { o as f } from "./structuredValue-vqCZttsk.js";
+import { jsx as n, jsxs as c } from "react/jsx-runtime";
+var h = (t) => f(t) && typeof t.module == "string" && t.module !== "" ? {
+  module: t.module,
+  ...typeof t.feature == "string" && t.feature !== "" ? { feature: t.feature } : {}
+} : void 0, l = (t, e) => t?.module === e?.module && (t?.feature ?? "") === (e?.feature ?? "");
+function m(t, e, d, s) {
+  return e.flatMap((a) => {
+    const i = d ? `${d}.${a.id}` : a.id;
+    return [{
+      key: `${t}.${i}`,
+      label: a.name,
+      depth: s,
+      target: {
+        module: t,
+        feature: i
+      },
+      module: !1
+    }, ...m(t, a.features, i, s + 1)];
+  });
+}
+var v = (t) => t.modules.flatMap((e) => [{
+  key: e.id,
+  label: e.name,
+  depth: 0,
+  target: { module: e.id },
+  module: !0
+}, ...m(e.id, e.features, "", 1)]), k = ({ value: t, onChange: e, context: d, disabled: s, id: a }) => {
+  const i = d.strings.editors.navigationItemTarget, p = d.lookups.structure ?? { modules: [] }, u = v(p), r = h(t), g = r !== void 0 && !u.some((o) => l(o.target, r));
+  return /* @__PURE__ */ c("div", {
+    id: a,
+    className: "studio-editor-target",
+    role: "listbox",
+    "aria-labelledby": `${a}-label`,
+    "aria-disabled": s,
+    children: [
+      /* @__PURE__ */ n("button", {
+        type: "button",
+        role: "option",
+        "aria-selected": r === void 0,
+        disabled: s,
+        className: "studio-editor-target__row",
+        "data-chosen": r === void 0 || void 0,
+        onClick: () => e(void 0),
+        children: i.notLinked
+      }),
+      u.map((o) => /* @__PURE__ */ c("button", {
+        type: "button",
+        role: "option",
+        "aria-selected": l(o.target, r),
+        disabled: s,
+        "data-module": o.module || void 0,
+        "data-chosen": l(o.target, r) || void 0,
+        className: "studio-editor-target__row",
+        style: { paddingInlineStart: `${12 + o.depth * 16}px` },
+        onClick: () => e(o.target),
+        children: [/* @__PURE__ */ n("span", { children: o.label }), o.module && /* @__PURE__ */ n("span", {
+          className: "studio-editor-target__kind",
+          children: i.module
+        })]
+      }, o.key)),
+      g && /* @__PURE__ */ n("span", {
+        className: "studio-editor-chip studio-editor-chip--error",
+        role: "alert",
+        children: i.unresolved([r.module, r.feature].filter(Boolean).join(" › "))
+      })
+    ]
+  });
+};
+export {
+  k as NavigationItemTargetEditor
+};

package/dist/screen-editor/{NavigationTargetEditor-DGnW5pVF.js → NavigationTargetEditor-BZ0uQnIl.js}

@@ -1,5 +1,5 @@
 import { o as g } from "./structuredValue-vqCZttsk.js";
-import { t as v } from "./SearchableSelect-WUNlC3tk.js";
+import { t as v } from "./SearchableSelect-C4yzIyo_.js";
 import { Fragment as f, jsx as l, jsxs as y } from "react/jsx-runtime";
 var T = (o) => typeof o == "string" && o !== "" ? o : g(o) && typeof o.screen == "string" && o.screen !== "" ? o.screen : void 0, C = ({ value: o, onChange: b, descriptor: t, context: n, disabled: h, id: c }) => {
   const r = n.strings.editors, d = n.lookups.destinations, s = T(o), a = d.find((e) => e.id === s), i = s !== void 0 && a === void 0, m = t.valueType === "destination", p = d.map((e) => ({

package/dist/screen-editor/{ReferenceEditor-BnI2Qd7H.js → ReferenceEditor-BGuaEvY7.js}

@@ -1,4 +1,4 @@
-import { t as h } from "./SearchableSelect-WUNlC3tk.js";
+import { t as h } from "./SearchableSelect-C4yzIyo_.js";
 import { Fragment as v, jsx as p, jsxs as g } from "react/jsx-runtime";
 var L = ({ value: s, onChange: d, descriptor: i, context: l, disabled: u, problem: b, id: n }) => {
   const o = l.strings.editors.select, c = i.editorOptions?.reference, m = c ? l.lookups.references(c.target) : [], r = typeof s == "string" && s !== "" ? s : void 0, t = m.map((e) => ({

package/dist/screen-editor/ReferenceTargetEditors-kxd9SIuG.js

@@ -0,0 +1,18 @@
+import { ReferenceEditor as t } from "./ReferenceEditor-BGuaEvY7.js";
+import { jsx as o } from "react/jsx-runtime";
+var i = (e) => (r) => /* @__PURE__ */ o(t, {
+  ...r,
+  descriptor: {
+    ...r.descriptor,
+    editorOptions: {
+      ...r.descriptor.editorOptions,
+      reference: {
+        target: e,
+        ...r.descriptor.editorOptions?.reference
+      }
+    }
+  }
+}), c = i("sampleData");
+export {
+  c as SampleDataEditor
+};

package/dist/screen-editor/{RenderingSlotEditor-Cani_PtT.js → RenderingSlotEditor-D0ppEIOx.js}

@@ -74,11 +74,11 @@ function u(i, n) {
   }
 }
 var p = ({ value: i, onChange: n, context: o, disabled: h, id: r }) => {
-  const l = o.strings.editors.renderingSlot, c = o.lookups.slots, t = typeof i == "string" && i !== "" ? i : void 0, a = t !== void 0 && !c.includes(t) ? [...c, t] : c;
+  const c = o.strings.editors.renderingSlot, l = o.lookups.slots, t = typeof i == "string" && i !== "" ? i : void 0, a = t !== void 0 && !l.includes(t) ? [...l, t] : l;
   return a.length === 0 ? /* @__PURE__ */ s("p", {
     id: r,
     className: "studio-editor-properties__hint",
-    children: l.none
+    children: c.none
   }) : /* @__PURE__ */ g("div", {
     id: r,
     className: "studio-editor-slot",
@@ -93,13 +93,13 @@ var p = ({ value: i, onChange: n, context: o, disabled: h, id: r }) => {
         disabled: h,
         className: `studio-editor-chip${e === t ? " studio-editor-chip--chosen" : ""}`,
         onClick: () => n(e === t ? void 0 : e),
-        children: e
+        children: c.names[e] ?? e
       }, e))
     }), /* @__PURE__ */ g("svg", {
       className: "studio-editor-slot__diagram",
       viewBox: "0 0 100 60",
       role: "img",
-      "aria-label": t ? l.diagram(t) : "",
+      "aria-label": t ? c.diagram(t) : "",
       children: [/* @__PURE__ */ s("rect", {
         x: "0.5",
         y: "0.5",

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

@@ -0,0 +1,15 @@
+import { type RefObject } from 'react';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import type { DesignModeStrings } from './DesignModeStrings';
+import type { DesignModeState } from './useDesignMode';
+export interface DesignModeChromeProps {
+    surface: RefObject<HTMLDivElement | null>;
+    state: DesignModeState;
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    editorStrings: ScreenEditorStrings;
+    strings: DesignModeStrings;
+}
+export declare const DesignModeChrome: ({ surface, state, controller, environment, editorStrings, strings }: DesignModeChromeProps) => import("react").JSX.Element | null;

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

@@ -0,0 +1,9 @@
+import { type RefObject } from 'react';
+import type { ScreenEditorController } from '../Host/ScreenEditorController';
+import type { DesignModeStrings } from './DesignModeStrings';
+export interface DesignModeFramesProps {
+    surface: RefObject<HTMLDivElement | null>;
+    controller: ScreenEditorController;
+    strings: DesignModeStrings;
+}
+export declare const DesignModeFrames: ({ surface, controller, strings }: DesignModeFramesProps) => import("react").JSX.Element;

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

@@ -0,0 +1,19 @@
+import type { InspectedProperty } from '@cratis/scene.model';
+import type { Rect } from '../Surface/dropRegionRects';
+import type { EditorContext } from '../PropertyEditors/Registry/PropertyEditorProps';
+import type { PropertyEditorRegistry } from '../PropertyEditors/Registry/PropertyEditorRegistry';
+import type { DesignModeStrings } from './DesignModeStrings';
+export interface DesignModePopoverProps {
+    registry: PropertyEditorRegistry;
+    property: InspectedProperty;
+    context: EditorContext;
+    componentId: string;
+    anchor: Rect;
+    opener: HTMLElement;
+    bounds: Rect;
+    title: string;
+    strings: DesignModeStrings;
+    onChange: (property: InspectedProperty, value: unknown) => void;
+    onClose: () => void;
+}
+export declare const DesignModePopover: ({ registry, property, context, componentId, anchor, opener, bounds, title, strings, onChange, onClose }: DesignModePopoverProps) => import("react").JSX.Element;

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

@@ -0,0 +1,73 @@
+export interface DesignModeStrings {
+    toolbarLabel: (itemLabel: string) => string;
+    titleField: string;
+    notLinked: string;
+    chooseSlice: string;
+    mainArea: string;
+    emphasis: Record<string, string>;
+    noSliceWarning: string;
+    readOnlyReasons: Record<string, string>;
+    inheritedFrom: (origin: string) => string;
+    editAtOwner: string;
+    choiceLabel: (title: string) => string;
+    close: string;
+    toolbar: {
+        opensAsDialog: string;
+        dialogFromSlice: (template: string) => string;
+        dialogDefault: (template: string) => string;
+        sliceHelp: string;
+        stateChangeHeading: string;
+        notInvokableHeading: string;
+        upgrade: string;
+        upgradeNote: (slice: string) => string;
+    };
+    navigation: {
+        application: string;
+        extendsNotice: string;
+        overrideHere: string;
+        editAtApplication: string;
+        backToModule: (module: string) => string;
+        tagLong: (region: string, sources: string) => string;
+        regionName: Record<string, string>;
+        inheritedFromApplication: string;
+        inheritedNote: (module: string) => string;
+        definedIn: (scope: string) => string;
+        inheritedReadOnly: string;
+        navigationItem: string;
+        label: string;
+        navigateTo: string;
+        renderIntoSlot: string;
+        icon: string;
+        notLinked: string;
+        mainArea: string;
+        sidePanel: string;
+        modeTitle: (region: string, scope: string) => string;
+        modeDescription: (region: string) => string;
+        modes: Record<'inherit' | 'extend' | 'override', {
+            title: string;
+            description: string;
+        }>;
+        copyPrompt: string;
+        copyYes: string;
+        copyNo: string;
+        logo: string;
+        logoTitle: string;
+        logoImage: string;
+        logoLocked: string;
+        target: {
+            heading: string;
+            application: string;
+            module: string;
+            unresolved: (target: string) => string;
+        };
+        problems: Record<string, string>;
+    };
+    announce: {
+        added: (label: string) => string;
+        moved: (label: string, position: number, of: number) => string;
+        duplicated: (label: string) => string;
+        removed: (label: string) => string;
+        refused: (reason: string) => string;
+    };
+}
+export declare const defaultDesignModeStrings: DesignModeStrings;

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

@@ -0,0 +1,19 @@
+import type { Rect } from '../Surface/dropRegionRects';
+import { type DesignModeItem, type DesignModeReadOnlyAction, type DesignModeSubject } from './designModeTypes';
+import type { DesignModeStrings } from './DesignModeStrings';
+export interface FloatingItemToolbarProps {
+    subject: DesignModeSubject;
+    item: DesignModeItem;
+    anchor: Rect;
+    bounds: Rect;
+    strings: DesignModeStrings;
+    renameToken: number;
+    chipLabel: (actionId: string, item: DesignModeItem) => string;
+    onRename: (label: string) => void;
+    onAction: (actionId: string) => void;
+    onChoice: (actionId: string, chip: HTMLElement) => void;
+    readOnlyActions: readonly DesignModeReadOnlyAction[];
+    onReadOnlyAction: (action: DesignModeReadOnlyAction) => void;
+    onLeave: () => void;
+}
+export declare const FloatingItemToolbar: ({ subject, item, anchor, bounds, strings, renameToken, chipLabel, onRename, onAction, onChoice, readOnlyActions, onReadOnlyAction, onLeave }: FloatingItemToolbarProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/EditorLogoContext.d.ts

@@ -0,0 +1,7 @@
+export interface EditorLogo {
+    title: string;
+    locked: boolean;
+    lockedReason: string;
+}
+export declare const EditorLogoContext: import("react").Context<EditorLogo | undefined>;
+export declare const EditorLogoBox: () => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/EditorNavigationScope.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import type { ApplicationStructure, NavigationModel } from '@cratis/scene.model';
+export interface EditorNavigationScopeProps {
+    structure: ApplicationStructure;
+    navigation: NavigationModel;
+    module: string | undefined;
+    logoLockedReason: string;
+    children: ReactNode;
+}
+export declare const EditorNavigationScope: ({ structure, navigation, module, logoLockedReason, children }: EditorNavigationScopeProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/navigationDocument.d.ts

@@ -0,0 +1,8 @@
+import { NavigationRegionKind, type NavigationModel, type NavItem, type SceneDocument } from '@cratis/scene.model';
+export type NavigationDocument = SceneDocument & {
+    navigation?: NavigationModel;
+};
+export declare const emptyNavigation: () => NavigationModel;
+export declare const navigationOf: (document: SceneDocument) => NavigationModel;
+export declare const withNavigation: (document: SceneDocument, navigation: NavigationModel) => SceneDocument;
+export declare function ownItemsOf(navigation: NavigationModel, module: string | undefined, region: NavigationRegionKind): NavItem[];

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/navigationItemOps.d.ts

@@ -0,0 +1,11 @@
+import type { NavItem } from '@cratis/scene.model';
+export declare const changeItem: (items: readonly NavItem[], id: string, change: Partial<NavItem>) => NavItem[];
+export declare const removeItem: (items: readonly NavItem[], id: string) => NavItem[];
+export declare function findItem(items: readonly NavItem[], id: string): NavItem | undefined;
+export declare function siblingsOf(items: readonly NavItem[], id: string): readonly NavItem[] | undefined;
+export declare function moveItem(items: readonly NavItem[], id: string, to: number): NavItem[];
+export declare const cloneItem: (item: NavItem, newId: () => string) => NavItem;
+export declare function duplicateItem(items: readonly NavItem[], id: string, newId: () => string): {
+    items: NavItem[];
+    copy?: NavItem;
+};

package/dist/screen-editor/ScreenEditor/DesignMode/Navigation/regionItemSource.d.ts

@@ -0,0 +1,25 @@
+import { NavigationRegionKind, type ApplicationStructure, type NavigationModel } from '@cratis/scene.model';
+import { type DesignModeItemSource } from '../designModeTypes';
+export interface RegionSourceInputs {
+    region: NavigationRegionKind;
+    module: string | undefined;
+    navigation: NavigationModel;
+    structure: ApplicationStructure;
+    newId: () => string;
+    slots: readonly string[];
+    startingLabel: string;
+    strings: RegionStrings;
+}
+export interface RegionStrings {
+    tagLong: (region: NavigationRegionKind, sources: string) => string;
+    extendsNotice: string;
+    overrideHere: string;
+    editAtApplication: string;
+    application: string;
+    mainArea: string;
+}
+export declare function targetLabel(structure: ApplicationStructure, target: {
+    module?: string;
+    feature?: string;
+} | undefined): string | undefined;
+export declare function createRegionItemSource(inputs: RegionSourceInputs): DesignModeItemSource;

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

@@ -0,0 +1,2 @@
+import type { SceneElement } from '@cratis/scene.model';
+export declare function cloneWithNewIds(element: SceneElement, newId: () => string): SceneElement;

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

@@ -0,0 +1,10 @@
+import { type DestinationReference, type InspectedProperty } from '@cratis/scene.model';
+import { type DesignModeItemSource } from './designModeTypes';
+export interface CollectionItemSourceInputs {
+    componentId: string;
+    property: InspectedProperty;
+    newId: () => string;
+    startingLabel: string;
+    startingDestination?: DestinationReference;
+}
+export declare function createCollectionItemSource({ componentId, property, newId, startingLabel, startingDestination }: CollectionItemSourceInputs): DesignModeItemSource;

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

@@ -0,0 +1,7 @@
+import { type DeleteKeyEvent } from '../Structure/isDeleteKey';
+import type { DesignModeState } from './useDesignMode';
+export interface DesignModeKeyEvent extends DeleteKeyEvent {
+    preventDefault: () => void;
+    stopPropagation: () => void;
+}
+export declare function handleDesignModeKey(event: DesignModeKeyEvent, state: DesignModeState, focusTitle: () => boolean): boolean;

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

@@ -0,0 +1,9 @@
+import type { DesignModeItemAction } from '@cratis/scene.model';
+import { type DesignModeItem } from './designModeTypes';
+export declare function isAvailableOn(action: DesignModeItemAction, item: DesignModeItem): boolean;
+export declare const inheritedReasonRule = "item.inherited";
+export interface ActionState {
+    visible: boolean;
+    enabled: boolean;
+}
+export declare function actionStateOf(action: DesignModeItemAction, item: DesignModeItem): ActionState;