@cratis/event-models 0.337.2 → 0.339.0

package/dist/screen-editor/ScreenEditor/Placement/HookOpensField.d.ts

@@ -0,0 +1,10 @@
+import type { PlacementEnvironment, HookPlacementInput } from './hookPlacement';
+import type { PlacementStrings } from './PlacementStrings';
+export interface HookOpensFieldProps {
+    hook: HookPlacementInput;
+    environment: PlacementEnvironment | undefined;
+    strings: PlacementStrings;
+    disabled?: boolean;
+    onChange: (value: string) => void;
+}
+export declare const HookOpensField: ({ hook, environment, strings, disabled, onChange }: HookOpensFieldProps) => import("react").JSX.Element | null;

package/dist/screen-editor/ScreenEditor/Placement/PlacementStrings.d.ts

@@ -0,0 +1,32 @@
+export interface PlacementStrings {
+    opens: string;
+    enabled: string;
+    choices: Record<'automatic' | 'none' | 'dialog' | 'drawer' | 'slot', {
+        label: string;
+        hint: string;
+    }>;
+    chipAutomatic: (resolved: string) => string;
+    chipNothingFits: string;
+    chipSlot: (slot: string) => string;
+    chipNotSet: string;
+    screenless: string;
+    chooseSlice: string;
+    slotsHeading: string;
+    noSlots: string;
+    slotKind: (role: string, routed: boolean) => string;
+    slotRoute: (url: string) => string;
+    slotPlaceholder: string;
+    derivedFrom: string;
+    actsOn: string;
+    actsOnChoices: Record<'' | 'item' | 'screen', string>;
+    condition: string;
+    conditionHint: string;
+    conditionPlaceholder: string;
+    conditionUnreadable: string;
+    steps: Record<'subject' | 'authorization' | 'condition', string>;
+    alwaysEnabled: string;
+    chipForItem: string;
+    chipForScreen: string;
+    chipWhen: (condition: string) => string;
+}
+export declare const defaultPlacementStrings: PlacementStrings;

package/dist/screen-editor/ScreenEditor/Placement/hookBinding.d.ts

@@ -0,0 +1,28 @@
+import { Opens, OutletSubject } from '@cratis/scene.model';
+import { type Enablement } from '@cratis/scene.engine';
+import type { HookPlacementInput, PlacementEnvironment } from './hookPlacement';
+import { type PlacementStrings } from './PlacementStrings';
+export interface HookOpensValue {
+    value: string;
+    hook: HookPlacementInput;
+}
+export interface HookEnabledValue extends EnabledValue {
+    hook: HookPlacementInput;
+    outletSubject?: OutletSubject;
+}
+export declare const opensValueOf: (opens: Opens | undefined, opensIn: string | undefined) => string;
+export declare function opensChangeOf(given: unknown): {
+    opens?: Opens;
+    opensIn?: string;
+} | undefined;
+export interface EnabledValue {
+    subject?: OutletSubject;
+    enabledWhen?: string;
+}
+export declare function enabledChangeOf(value: unknown): {
+    subject?: OutletSubject;
+    enabledWhen?: string;
+} | undefined;
+export declare function opensChipText(hook: HookPlacementInput, environment: PlacementEnvironment | undefined, text?: PlacementStrings): string;
+export declare function enabledChipText(hook: HookPlacementInput, outletSubject: OutletSubject | undefined, text?: PlacementStrings): string;
+export declare const whyDisabled: (enablement: Enablement) => string | undefined;

package/dist/screen-editor/ScreenEditor/Placement/hookPlacement.d.ts

@@ -0,0 +1,27 @@
+import { Opens, OutletSubject, type Layout, type SceneDocument, type ScreenTemplate } from '@cratis/scene.model';
+import { type Enablement, type EnablementPersona, type PlacementDecision, type PlacementInput, type PlacementSlot } from '@cratis/scene.engine';
+import { type StateChangeSlice } from '../Actions/StateChangeSlice';
+export interface PlacementEnvironment {
+    slices: readonly StateChangeSlice[];
+    slots: readonly PlacementSlot[];
+    itemFields: ReadonlySet<string>;
+    routeParameters: readonly string[];
+    persona?: EnablementPersona;
+}
+export interface HookPlacementInput {
+    slice?: string;
+    opens?: Opens;
+    opensIn?: string;
+    subject?: OutletSubject;
+    enabledWhen?: string;
+    mapping?: Readonly<Record<string, string>>;
+}
+export interface HookInspection {
+    slice?: StateChangeSlice;
+    screenless: boolean;
+    placement?: PlacementDecision;
+    enablement: Enablement;
+}
+export declare function placementInputsOf(slice: StateChangeSlice, hook: HookPlacementInput, environment: Pick<PlacementEnvironment, 'itemFields' | 'routeParameters'>): PlacementInput[];
+export declare function inspectHook(hook: HookPlacementInput, environment: PlacementEnvironment): HookInspection;
+export declare function screenPlacementSlots(document: SceneDocument, templates: readonly ScreenTemplate[], layouts: readonly Layout[], screen: string): PlacementSlot[];

package/dist/screen-editor/ScreenEditor/Placement/opensOptions.d.ts

@@ -0,0 +1,16 @@
+import { Opens } from '@cratis/scene.model';
+import type { PlacementDecision, PlacementRoute, SlotOption } from '@cratis/scene.engine';
+import { type HookInspection, type HookPlacementInput, type PlacementEnvironment } from './hookPlacement';
+export interface OpensOption {
+    value: Opens;
+    available: boolean;
+    reason: string;
+}
+export interface OpensChoices {
+    inspection: HookInspection;
+    decision?: PlacementDecision;
+    options: readonly OpensOption[];
+    slots: readonly SlotOption[];
+}
+export declare const routeText: (route: PlacementRoute) => string;
+export declare function opensChoicesFor(hook: HookPlacementInput, environment: PlacementEnvironment): OpensChoices;

package/dist/screen-editor/ScreenEditor/Placement/placementEnvironment.d.ts

@@ -0,0 +1,12 @@
+import { type Layout, type QueryCandidate, type SceneDocument, type ScreenTemplate } from '@cratis/scene.model';
+import type { StateChangeSlice } from '../Actions/StateChangeSlice';
+import { type PlacementEnvironment } from './hookPlacement';
+export interface PlacementEnvironmentInputs {
+    document: SceneDocument;
+    screen: string;
+    slices: readonly StateChangeSlice[];
+    queries: readonly QueryCandidate[];
+    templates?: readonly ScreenTemplate[];
+    layouts?: readonly Layout[];
+}
+export declare function placementEnvironmentOf({ document, screen, slices, queries, templates, layouts }: PlacementEnvironmentInputs): PlacementEnvironment;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Registry/PropertyEditorProps.d.ts

@@ -5,6 +5,7 @@ import type { EffectiveIconCatalog } from '@cratis/scene.engine';
 import type { IconAdapterRegistry } from '@cratis/scene.react';
 import type { BindingTypeScope } from '@cratis/scene.engine';
 import type { StateChangeSlice } from '../../Actions/StateChangeSlice';
+import type { PlacementEnvironment } from '../../Placement/hookPlacement';
 import type { ScreenEditorController } from '../../Host/ScreenEditorController';
 import type { ScreenEditorEnvironment } from '../../Host/ScreenEditorHost';
 import type { ScreenEditorStrings } from '../../Inspector/ScreenEditorStrings';
@@ -37,6 +38,7 @@ export interface EditorSession {
     copyInheritedItems?: (copy: boolean) => void;
 }
 export interface EditorLookups {
+    placement?: PlacementEnvironment;
     stateChangeSlices: readonly StateChangeSlice[];
     slices: readonly EditorSlice[];
     destinations: readonly ConfigurationDestination[];

package/dist/screen-editor/ScreenEditor/PropertyEditors/Registry/PropertyEditorStrings.d.ts

@@ -1,4 +1,6 @@
+import { type PlacementStrings } from '../../Placement/PlacementStrings';
 export interface PropertyEditorStrings {
+    placement: PlacementStrings;
     readOnly: string;
     inherited: string;
     unresolved: string;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Specific/HookEditors.d.ts

@@ -0,0 +1,4 @@
+import type { HookEnabledValue, HookOpensValue } from '../../Placement/hookBinding';
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const HookOpensEditor: ({ value, onChange, context, disabled }: PropertyEditorProps<HookOpensValue>) => import("react").JSX.Element;
+export declare const HookEnabledEditor: ({ value, onChange, context, disabled }: PropertyEditorProps<HookEnabledValue>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Specific/QueryBindingPropertyEditor.d.ts

@@ -1,3 +1,3 @@
 import type { QueryBinding } from '@cratis/scene.model';
 import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
-export declare const QueryBindingPropertyEditor: ({ onChange, context, disabled }: PropertyEditorProps<QueryBinding>) => import("react").JSX.Element | null;
+export declare const QueryBindingPropertyEditor: ({ value, onChange, context, disabled }: PropertyEditorProps<QueryBinding>) => import("react").JSX.Element | null;

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

@@ -1,5 +1,5 @@
 import { type BindingResolver } from '@cratis/scene.engine';
-import type { EffectiveConfiguration } from '@cratis/scene.model';
+import { type EffectiveConfiguration } from '@cratis/scene.model';
 import type { ScreenEditorController } from '../Host/ScreenEditorController';
 import type { ScreenEditorEnvironment } from '../Host/ScreenEditorHost';
 import type { SurfaceStrings } from './DesignTime/SurfaceStrings';

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

@@ -0,0 +1,6 @@
+export declare const columnAt: (headerMiddles: readonly number[], pointer: number) => number | undefined;
+export interface TableDrop {
+    elementId: string;
+    column?: number;
+}
+export declare function tableDropAt(target: EventTarget | null, pointer: number): TableDrop | undefined;

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

@@ -6,7 +6,7 @@ export interface DragFeedback {
     drop?: ResolvedDrop;
     denied: boolean;
 }
-type Controller = Pick<ScreenEditorController, 'insertComponent' | 'insertLayout' | 'ownershipOf' | 'move' | 'validateMove' | 'composition' | 'adapter'>;
+type Controller = Pick<ScreenEditorController, 'insertComponent' | 'insertLayout' | 'insertDataField' | 'ownershipOf' | 'move' | 'validateMove' | 'composition' | 'adapter'>;
 export declare function useSurfaceDrop(surface: RefObject<HTMLDivElement | null>, measureNow: () => PlacedRegion[], controller: Controller): {
     feedback: DragFeedback | undefined;
     draggedId: string | undefined;

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

@@ -4,7 +4,11 @@ export interface EditorComposition {
     element: Panel;
     roots: SceneElement[];
     own: SceneElement[];
+    chrome: SceneElement[];
     templates: string[];
     entry?: string;
 }
-export declare function composeEditorScreen(document: SceneDocument, authoredTemplate?: string): EditorComposition;
+export interface EditorCompositionOptions {
+    dialogActions?: boolean;
+}
+export declare function composeEditorScreen(document: SceneDocument, authoredTemplate?: string, options?: EditorCompositionOptions): EditorComposition;

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

@@ -0,0 +1,9 @@
+import { type DialogTemplate, type Layout, type Outlet, type SceneDocument, type SceneElement, type ScreenTemplate } from '@cratis/scene.model';
+export declare const dialogActionsChromeId = "dialog-actions-chrome";
+export declare const defaultDialogTemplateName = "FormDialog";
+export declare function screenFitsDialog(document: SceneDocument): boolean;
+export declare function dialogTemplateOf(document: SceneDocument): DialogTemplate;
+export declare function dialogActionsOutletOf(template: DialogTemplate): Outlet | undefined;
+export declare function showsDialogActions(document: SceneDocument, templates?: readonly ScreenTemplate[], layouts?: readonly Layout[]): boolean;
+export declare function documentWithChrome(document: SceneDocument, chrome: readonly SceneElement[]): SceneDocument;
+export declare function dialogActionsChrome(): SceneElement;

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

@@ -6,6 +6,7 @@ export declare const slotOfSection: (id: string) => string;
 export declare const needsSlotSections: (template: ScreenTemplate) => boolean;
 export declare function slotTargetOf(parentId: string, authoredTemplate: string | undefined): string | undefined;
 export declare const slotIndexOf: (parentId: string, index: number) => number;
+export declare function slotLabelOf(template: ScreenTemplate, slot: string): string;
 /**
  * The slots of a template as the sections they are drawn in.
  *

package/dist/screen-editor/defaultStructuredEditorStrings-Bwbw58wD.js

@@ -0,0 +1,116 @@
+import { n as c } from "./sceneTree-CNx3I3MJ.js";
+import { BindingMode as p, BindingNullBehavior as l, BindingSourceKind as r, PropertyValueType as o } from "@cratis/scene.model";
+import { elementNodeId as m, inspect as v } from "@cratis/scene.engine";
+function C(e, t, s, i, d) {
+  const a = c(t).map((n) => y(e, n, s)).filter((n) => !!n && n.outputs.length > 0);
+  return {
+    dataContextPaths: Object.keys(i).sort((n, u) => n.localeCompare(u)),
+    queryResults: d.map((n) => ({
+      id: n.id,
+      name: n.name,
+      fields: n.resultFields.map((u) => u.name)
+    })),
+    componentOutputs: a
+  };
+}
+function y(e, t, s) {
+  const i = v(e, m(t), s);
+  if (!i) return;
+  const d = i.properties.filter((a) => a.descriptor.output === !0).map((a) => ({
+    path: a.descriptor.path,
+    label: a.descriptor.label,
+    type: String(a.descriptor.valueType)
+  }));
+  return {
+    componentId: t,
+    label: i.label,
+    outputs: d
+  };
+}
+var g = [
+  r.DataContext,
+  r.QueryResult,
+  r.ComponentProperty,
+  r.Literal,
+  r.CommandResponse
+], T = [
+  r.DataContext,
+  r.QueryResult,
+  r.ComponentProperty,
+  r.Literal
+], w = [p.OneWay, p.TwoWay], x = [
+  l.Propagate,
+  l.Clear,
+  l.Preserve
+], B = [
+  o.String,
+  o.Number,
+  o.Boolean,
+  o.Enum,
+  o.Icon,
+  o.Destination,
+  o.QueryReference,
+  o.Collection,
+  o.Object,
+  o.Json
+];
+function f(e) {
+  const t = e;
+  return !!t && typeof t == "object" && typeof t.path == "string" && (t.kind === void 0 || g.includes(t.kind));
+}
+function E(e) {
+  return (e.descriptor.acceptedBindingKinds?.length ?? 0) > 0 || f(e.effectiveValue);
+}
+function M(e) {
+  return {
+    kind: e.descriptor.acceptedBindingKinds?.[0] ?? r.DataContext,
+    path: "",
+    mode: e.descriptor.bindingMode,
+    expectedValueType: e.descriptor.valueType
+  };
+}
+var N = {
+  unset: "Not set",
+  item: "Item",
+  itemTitle: (e, t) => `${e} ${t}`,
+  add: (e) => `Add ${e.toLowerCase()}`,
+  remove: (e, t) => `Remove ${e.toLowerCase()} ${t}`,
+  removeText: "Remove",
+  moveUp: (e, t) => `Move ${e.toLowerCase()} ${t} up`,
+  moveUpText: "Up",
+  moveDown: (e, t) => `Move ${e.toLowerCase()} ${t} down`,
+  moveDownText: "Down",
+  entry: (e) => `Entry ${e}`,
+  moveEntryUp: (e) => `Move entry ${e} up`,
+  moveEntryDown: (e) => `Move entry ${e} down`,
+  removeEntry: (e) => `Remove entry ${e}`,
+  addEntry: "Add entry",
+  useList: "Use a list",
+  useSingle: "Use one value",
+  scalarType: "Type",
+  scalarText: "Text",
+  scalarNumber: "Number",
+  scalarFlag: "Yes or no",
+  scalarFlagOn: "Yes",
+  mapName: (e) => `Name ${e}`,
+  mapValue: (e) => `Value of ${e}`,
+  addMapEntry: "Add value",
+  removeMapEntry: (e) => `Remove ${e}`,
+  keptValue: "A structured value, kept as it is.",
+  mismatch: (e, t) => `The saved value of '${e}' does not fit what it is described as: ${t}.`,
+  convert: "Give its items identifiers",
+  clear: "Clear the value",
+  noEditor: (e) => `'${e}' has no editor: nothing describes what it holds, so it cannot be edited here.`
+};
+export {
+  T as a,
+  f as c,
+  x as i,
+  E as l,
+  g as n,
+  M as o,
+  w as r,
+  B as s,
+  N as t,
+  C as u
+};

package/dist/screen-editor/hookBinding-DOpu2dMp.js

@@ -0,0 +1,171 @@
+import { Opens as a, OutletSubject as c } from "@cratis/scene.model";
+import { InputSourceKind as d, argumentSourceKind as p, placementSlotsOf as h, resolveEnablement as m, resolvePlacement as f } from "@cratis/scene.engine";
+var b = (e) => e.commandName ?? e.name;
+function v(e, t) {
+  if (typeof t != "string" || t === "") return;
+  const n = e.find((s) => s.id === t);
+  if (n) return n;
+  const i = e.filter((s) => b(s) === t);
+  return i.length === 1 ? i[0] : void 0;
+}
+function S(e, t, n) {
+  return e.inputs.map((i) => {
+    const s = t.mapping ? p(t.mapping[i.name]) : t.subject === c.Item && n.itemFields.has(i.name) ? d.DataContext : n.routeParameters.includes(i.name) ? d.Route : void 0;
+    return s === void 0 ? { name: i.name } : {
+      name: i.name,
+      source: s
+    };
+  });
+}
+function g(e, t) {
+  const n = e.slice === void 0 ? void 0 : v(t.slices, e.slice), i = m({
+    ...e.subject ? { subject: e.subject } : {},
+    ...n?.authorize ? { authorize: n.authorize } : {},
+    ...t.persona ? { persona: t.persona } : {},
+    ...e.enabledWhen ? { enabledWhen: e.enabledWhen } : {}
+  });
+  if (!n) return {
+    screenless: !1,
+    enablement: i
+  };
+  const s = f({
+    slice: n.id,
+    ...e.opens ? { opens: e.opens } : {},
+    ...e.opensIn ? { opensIn: e.opensIn } : {},
+    ...n.screenless ? {} : { screen: n.name },
+    ...n.fits ? { fits: [...n.fits] } : {},
+    inputs: S(n, e, t),
+    slots: [...t.slots]
+  });
+  return {
+    slice: n,
+    screenless: n.screenless === !0,
+    placement: s,
+    enablement: i
+  };
+}
+var O = (e, t, n, i) => {
+  const s = e.screens.find((o) => o.name === i) ?? e.screens[0], l = Object.entries(s?.slotContent ?? {}).filter(([, o]) => o.length > 0).map(([o]) => o), r = s?.screenTemplate ? e.screenTemplates.find((o) => o.name === s.screenTemplate) ?? t.find((o) => o.name === s.screenTemplate) : void 0;
+  return r ? {
+    slots: r.slots,
+    filled: l
+  } : {
+    slots: (s ? e.layouts.find((o) => o.name === s.layout) ?? n.find((o) => o.name === s.layout) : void 0)?.slots ?? [],
+    filled: l
+  };
+};
+function j(e, t, n, i) {
+  const { slots: s, filled: l } = O(e, t, n, i);
+  return h(s, l);
+}
+var u = {
+  opens: "Opens",
+  enabled: "Enabled",
+  choices: {
+    automatic: {
+      label: "Automatic",
+      hint: "The slice's first fit that the page has free."
+    },
+    none: {
+      label: "Run directly",
+      hint: "Issues the command without asking."
+    },
+    dialog: {
+      label: "Dialog",
+      hint: "Opens the slice’s screen over the page."
+    },
+    drawer: {
+      label: "Drawer",
+      hint: "Opens the slice’s screen in a drawer beside the page."
+    },
+    slot: {
+      label: "In a slot",
+      hint: "Opens the slice’s screen in a slot of the page."
+    }
+  },
+  chipAutomatic: (e) => `Automatic · ${e}`,
+  chipNothingFits: "Automatic · nothing fits",
+  chipSlot: (e) => `In ${e}`,
+  chipNotSet: "Choose a slice",
+  screenless: "This slice has no screen, so it can only run directly.",
+  chooseSlice: "Choose a slice first: where it opens depends on what it fits and needs.",
+  slotsHeading: "Slots of this page",
+  noSlots: "The page has no slots a slice could be put in.",
+  slotKind: (e, t) => t ? `${e}, routed` : e,
+  slotRoute: (e) => `Opening here changes the URL to ${e}`,
+  slotPlaceholder: "Choose a slot",
+  derivedFrom: "Enabled, worked out from",
+  actsOn: "Acts on",
+  actsOnChoices: {
+    "": "What the outlet says",
+    item: "A selected item",
+    screen: "The screen"
+  },
+  condition: "Enabled when",
+  conditionHint: 'Compare what the selected item has, such as item.status == "onSale"; join with and / or.',
+  conditionPlaceholder: 'item.status == "onSale"',
+  conditionUnreadable: "Scene cannot read this condition, so it will not be saved.",
+  steps: {
+    subject: "Subject",
+    authorization: "Authorization",
+    condition: "Condition"
+  },
+  alwaysEnabled: "Always",
+  chipForItem: "For item",
+  chipForScreen: "For screen",
+  chipWhen: (e) => `when ${e}`
+}, w = (e, t) => e === a.Slot ? t ? `slot:${t}` : "slot" : e ?? a.Automatic;
+function A(e) {
+  const t = typeof e == "object" && e !== null && "value" in e ? e.value : e;
+  if (t == null || t === "" || t === a.Automatic) return {
+    opens: void 0,
+    opensIn: void 0
+  };
+  if (typeof t == "string")
+    return t === a.Slot ? {
+      opens: a.Slot,
+      opensIn: void 0
+    } : t.startsWith("slot:") ? {
+      opens: a.Slot,
+      opensIn: t.slice(5) || void 0
+    } : Object.values(a).includes(t) ? {
+      opens: t,
+      opensIn: void 0
+    } : void 0;
+}
+function C(e) {
+  if (e == null) return {
+    subject: void 0,
+    enabledWhen: void 0
+  };
+  if (typeof e != "object") return;
+  const { subject: t, enabledWhen: n } = e;
+  return {
+    subject: t === c.Item || t === c.Screen ? t : void 0,
+    enabledWhen: typeof n == "string" && n.trim() !== "" ? n.trim() : void 0
+  };
+}
+function W(e, t, n = u) {
+  const i = (l) => n.choices[l ?? a.Automatic]?.label ?? String(l);
+  if (e.opens === a.Slot) return n.chipSlot(e.opensIn ?? n.choices.slot.label);
+  if (e.opens !== void 0 && e.opens !== a.Automatic) return i(e.opens);
+  if (!t || !e.slice) return i(a.Automatic);
+  const s = g(e, t).placement;
+  return s ? s.resolved === void 0 ? n.chipNothingFits : n.chipAutomatic(s.resolved === a.Slot ? n.chipSlot(s.slot ?? "") : i(s.resolved)) : i(a.Automatic);
+}
+function T(e, t, n = u) {
+  const i = [...(e.subject ?? t) === c.Item ? [n.chipForItem] : [], ...e.enabledWhen ? [n.chipWhen(e.enabledWhen)] : []];
+  return i.length > 0 ? i.join(" · ") : n.alwaysEnabled;
+}
+export {
+  w as a,
+  j as c,
+  W as i,
+  b as l,
+  T as n,
+  u as o,
+  A as r,
+  g as s,
+  C as t,
+  v as u
+};