@cratis/event-models 0.174.0 → 0.176.0

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/EnumEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const EnumEditor: ({ value, onChange, descriptor, disabled, id }: PropertyEditorProps<unknown>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/IconEditor.d.ts

@@ -0,0 +1,3 @@
+import { type IconReference } from '@cratis/scene.model';
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const IconEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<IconReference>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/ListEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const ListEditor: ({ value, onChange, descriptor, context, disabled, id }: PropertyEditorProps<unknown[]>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/NumberEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const NumberEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<number>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/ReferenceEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const ReferenceEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<string>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/SelectEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const SelectEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<unknown>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/TextEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const TextEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<string>) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/PropertyEditors/Generic/draftProblem.d.ts

@@ -0,0 +1,3 @@
+import type { PropertyDescriptor } from '@cratis/scene.model';
+import type { EditorProblem } from '../Registry/PropertyEditorProps';
+export declare function draftProblem(descriptor: PropertyDescriptor, value: unknown): EditorProblem | undefined;

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

@@ -0,0 +1,13 @@
+import type { InspectedProperty, SceneDiagnostic } from '@cratis/scene.model';
+import type { EditorContext, EditorProblem } from './PropertyEditorProps';
+import type { PropertyEditorRegistry } from './PropertyEditorRegistry';
+export interface PropertyEditorHostProps {
+    registry: PropertyEditorRegistry;
+    property: InspectedProperty;
+    context: EditorContext;
+    componentId: string;
+    onChange: (property: InspectedProperty, value: unknown) => void;
+    diagnostics: readonly SceneDiagnostic[];
+}
+export declare const PropertyEditorHost: ({ registry, property, context, componentId, onChange, diagnostics }: PropertyEditorHostProps) => import("react").JSX.Element;
+export declare function problemOf(property: InspectedProperty, diagnostics: readonly SceneDiagnostic[]): EditorProblem | undefined;

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

@@ -0,0 +1,91 @@
+import type { ComponentType } from 'react';
+import type { ConfigurationDestination } from '@cratis/components/ConfigurationEditor';
+import type { InspectedProperty, PropertyDescriptor, QueryCandidate, QueryResultField, SceneDiagnostic, SceneDocument } from '@cratis/scene.model';
+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 { ScreenEditorController } from '../../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from '../../Inspector/ScreenEditorStrings';
+import type { Ownership } from '../../Structure/Ownership';
+import type { StructuredEditorStrings } from '../Structured/StructuredEditorStrings';
+import type { PropertyEditorStrings } from './PropertyEditorStrings';
+import type { IconPropertyFieldStrings } from '../../../Icons/IconPropertyFieldStrings';
+export interface EditorContext {
+    model: SceneDocument;
+    selection?: {
+        id: string;
+        component: string;
+        properties: Readonly<Record<string, unknown>>;
+    };
+    level: 'screen' | 'template';
+    structure: {
+        ownership?: Ownership;
+        onCanvas: boolean;
+    };
+    lookups: EditorLookups;
+    strings: EditorStrings;
+    session?: EditorSession;
+}
+export interface EditorSession {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    property: InspectedProperty;
+    bindingScope: BindingTypeScope;
+    screenStrings: ScreenEditorStrings;
+    copyInheritedItems?: (copy: boolean) => void;
+}
+export interface EditorLookups {
+    stateChangeSlices: readonly StateChangeSlice[];
+    slices: readonly EditorSlice[];
+    destinations: readonly ConfigurationDestination[];
+    slots: readonly string[];
+    queryCandidates: readonly QueryCandidate[];
+    availableSources: Readonly<Record<string, string>>;
+    fields: readonly QueryResultField[];
+    colorTokens: readonly ColorToken[];
+    icons: {
+        catalog: EffectiveIconCatalog;
+        adapters: IconAdapterRegistry;
+        diagnostics: readonly SceneDiagnostic[];
+    };
+    references: (target: string) => readonly EditorReference[];
+}
+export interface EditorSlice {
+    id: string;
+    name: string;
+    kind: string;
+    path: readonly string[];
+}
+export interface ColorToken {
+    name: string;
+    label: string;
+    value?: string;
+}
+export interface EditorReference {
+    id: string;
+    label: string;
+    group?: string;
+}
+export interface EditorStrings {
+    editors: PropertyEditorStrings;
+    structured: StructuredEditorStrings;
+    icon: IconPropertyFieldStrings;
+    iconPicker: Record<string, string>;
+}
+export interface PropertyEditorProps<T = unknown> {
+    value: T | undefined;
+    onChange: (value: T | undefined) => void;
+    descriptor: PropertyDescriptor;
+    context: EditorContext;
+    disabled?: boolean;
+    readOnlyReason?: string;
+    problem?: EditorProblem;
+    id: string;
+}
+export interface EditorProblem {
+    code: string;
+    message: string;
+}
+export type PropertyEditor<T = unknown> = ComponentType<PropertyEditorProps<T>>;

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

@@ -0,0 +1,24 @@
+import type { ReactNode } from 'react';
+import { type PropertyDescriptor } from '@cratis/scene.model';
+import type { PropertyEditor } from './PropertyEditorProps';
+export type PropertyEditorLoader = () => Promise<(props: never) => ReactNode>;
+export type EditorResolutionTier = 'kind' | 'package' | 'default';
+export interface EditorResolution {
+    id: string;
+    tier: EditorResolutionTier;
+}
+export interface ResolveOptions {
+    packageEditor?: boolean;
+}
+export declare const maximumChipChoices = 4;
+export declare function defaultEditorId(descriptor: PropertyDescriptor): string | undefined;
+export declare class PropertyEditorRegistry {
+    #private;
+    register(id: string, loader: PropertyEditorLoader): this;
+    loadedOf(id: string): PropertyEditor<unknown> | undefined;
+    load(id: string): Promise<PropertyEditor<unknown>>;
+    has(id: string): boolean;
+    get ids(): readonly string[];
+    loaderOf(id: string): PropertyEditorLoader | undefined;
+    resolve(descriptor: PropertyDescriptor, options?: ResolveOptions): EditorResolution | undefined;
+}

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

@@ -0,0 +1,73 @@
+export interface PropertyEditorStrings {
+    readOnly: string;
+    inherited: string;
+    unresolved: string;
+    undescribed: (label: string) => string;
+    cannotLoad: (label: string) => string;
+    loading: string;
+    select: {
+        placeholder: string;
+        search: string;
+        empty: string;
+        clear: string;
+        notAvailable: (kind: string) => string;
+    };
+    text: {
+        placeholder: string;
+    };
+    number: {
+        invalid: string;
+    };
+    color: {
+        tokens: string;
+        custom: string;
+        clear: string;
+        hex: string;
+    };
+    list: {
+        add: string;
+        remove: string;
+        moveUp: string;
+        moveDown: string;
+    };
+    navigationTarget: {
+        placeholder: string;
+        unresolved: (target: string) => string;
+    };
+    renderingSlot: {
+        none: string;
+        diagram: (slot: string) => string;
+    };
+    slice: {
+        placeholder: string;
+        notKind: (kind: string) => string;
+    };
+    inheritanceMode: {
+        modes: Record<'inherit' | 'extend' | 'override', {
+            label: string;
+            effect: string;
+        }>;
+        copyPrompt: string;
+        copyYes: string;
+        copyNo: string;
+    };
+    field: {
+        placeholder: string;
+        typed: (kind: string) => string;
+    };
+    columnList: {
+        add: string;
+        remove: string;
+        field: string;
+        header: string;
+        width: string;
+        align: string;
+        format: string;
+        alignments: Record<'start' | 'center' | 'end', string>;
+    };
+    summary: {
+        editedBy: (owner: string) => string;
+        empty: string;
+    };
+}
+export declare const defaultPropertyEditorStrings: PropertyEditorStrings;

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

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+export interface SelectOption {
+    value: string;
+    label: string;
+    group?: string;
+    disabled?: boolean;
+    reason?: string;
+}
+export declare function filterOptions(options: readonly SelectOption[], query: string): SelectOption[];
+export interface SearchableSelectProps {
+    id: string;
+    options: readonly SelectOption[];
+    value: string | undefined;
+    onChange: (value: string | undefined) => void;
+    disabled?: boolean;
+    invalid?: boolean;
+    placeholder: string;
+    searchLabel: string;
+    emptyLabel: string;
+    clearLabel: string;
+    clearable?: boolean;
+    renderClosed?: (option: SelectOption | undefined) => ReactNode;
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+}
+export declare const SearchableSelect: ({ id, options, value, onChange, disabled, invalid, placeholder, searchLabel, emptyLabel, clearLabel, clearable, renderClosed, ...aria }: SearchableSelectProps) => import("react").JSX.Element;

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

@@ -0,0 +1,20 @@
+import type { InspectedProperty, QueryCandidate, QueryResultField, SceneDiagnostic } from '@cratis/scene.model';
+import type { BindingTypeScope } from '@cratis/scene.engine';
+import type { ScreenEditorController } from '../../Host/ScreenEditorController';
+import type { ScreenEditorEnvironment } from '../../Host/ScreenEditorHost';
+import type { ScreenEditorStrings } from '../../Inspector/ScreenEditorStrings';
+import type { Ownership } from '../../Structure/Ownership';
+import type { EditorContext } from './PropertyEditorProps';
+export interface EditorContextInputs {
+    controller: ScreenEditorController;
+    environment: ScreenEditorEnvironment;
+    strings: ScreenEditorStrings;
+    ownership: Ownership | undefined;
+    authoringTemplate?: string;
+    diagnostics: readonly SceneDiagnostic[];
+    inCanvas: boolean;
+    bindingScope: BindingTypeScope;
+}
+export declare function fieldsOfBoundQuery(properties: Readonly<Record<string, unknown>> | undefined, candidates: readonly QueryCandidate[]): readonly QueryResultField[];
+export declare function createEditorContext(inputs: EditorContextInputs): EditorContext;
+export declare function withSession(context: EditorContext, inputs: EditorContextInputs, property: InspectedProperty): EditorContext;

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

@@ -0,0 +1,2 @@
+import { PropertyEditorRegistry } from './PropertyEditorRegistry';
+export declare function createPropertyEditorRegistry(): PropertyEditorRegistry;

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

@@ -0,0 +1 @@
+export declare const screenEditorPropertyEditors: import("./PropertyEditorRegistry").PropertyEditorRegistry;

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

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

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const CollectionEditor: (props: PropertyEditorProps<unknown>) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const ColumnListEditor: ({ value, onChange, descriptor, context, disabled, id }: PropertyEditorProps<Record<string, unknown>[]>) => import("react").JSX.Element;

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

@@ -0,0 +1,23 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare function fieldCandidates(descriptor: {
+    editorKind?: string;
+    editorOptions?: {
+        fieldKinds?: string[];
+    };
+}, lookups: {
+    fields: readonly {
+        name: string;
+        type: string;
+    }[];
+    availableSources: Readonly<Record<string, string>>;
+}): {
+    all: {
+        name: string;
+        type: string;
+    }[];
+    offered: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const FieldEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<string>) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const FieldListEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<string[]>) => import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+type Mode = 'inherit' | 'extend' | 'override';
+export declare const InheritanceModeEditor: ({ value, onChange, context, disabled, id }: PropertyEditorProps<Mode>) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const NavigationTargetEditor: ({ value, onChange, descriptor, context, disabled, id }: PropertyEditorProps<unknown>) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const OrderedItemsEditor: ({ context }: PropertyEditorProps<unknown>) => import("react").JSX.Element | null;

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

@@ -0,0 +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;

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

@@ -0,0 +1,3 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const TemplateEditor: (props: PropertyEditorProps<string>) => import("react").JSX.Element;
+export declare const SampleDataEditor: (props: PropertyEditorProps<string>) => import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare function slotRegion(slot: string, slots: readonly string[]): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare const RenderingSlotEditor: ({ value, onChange, context, disabled, id }: PropertyEditorProps<string>) => import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+import type { PropertyEditorProps, EditorLookups } from '../Registry/PropertyEditorProps';
+import type { PropertyEditorStrings } from '../Registry/PropertyEditorStrings';
+import type { SelectOption } from '../Registry/SearchableSelect';
+export declare function sliceOptions(lookups: Pick<EditorLookups, 'slices' | 'stateChangeSlices'>, kinds: readonly string[] | undefined, text: PropertyEditorStrings): SelectOption[];
+export declare const SliceEditor: ({ value, onChange, descriptor, context, disabled, problem, id }: PropertyEditorProps<string>) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const StateChangeEditor: (props: PropertyEditorProps<string>) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const StructuredPropertyEditor: ({ value, onChange, descriptor, context, disabled, id }: PropertyEditorProps<unknown>) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const SummaryEditor: ({ value, descriptor, context, id }: PropertyEditorProps<unknown>) => import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+import type { PropertyEditorProps } from '../Registry/PropertyEditorProps';
+export declare const UndescribedEditor: ({ descriptor, context, id }: PropertyEditorProps<unknown>) => import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function fieldKindOf(type: string): 'number' | 'boolean' | 'date' | 'id' | 'string';

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

@@ -1,8 +1,5 @@
 export * from './StructuredEditorStrings';
-export * from './classifyStructures';
-export * from './StructuredProperties';
 export * from './StructuredValueEditor';
-export * from './UndescribedProperties';
 export * from './defaultStructuredEditorStrings';
 export * from './structuredValue';
 export * from './structuredProblem';

package/dist/screen-editor/SearchableSelect-WUNlC3tk.js

@@ -0,0 +1,109 @@
+import { useId as O, useMemo as q, useRef as B, useState as f } from "react";
+import { jsx as l, jsxs as c } from "react/jsx-runtime";
+function F(d, r) {
+  const s = r.trim().toLowerCase();
+  return d.filter((a) => s === "" || a.label.toLowerCase().includes(s) || (a.group ?? "").toLowerCase().includes(s));
+}
+var R = ({ id: d, options: r, value: s, onChange: a, disabled: _, invalid: D, placeholder: C, searchLabel: b, emptyLabel: M, clearLabel: A, clearable: S, renderClosed: v, ...j }) => {
+  const [i, g] = f(!1), [u, w] = f(""), [y, h] = f(0), N = O(), k = B(null), m = r.find((e) => e.value === s), n = q(() => F(r, u), [r, u]), o = n.filter((e) => e.disabled !== !0), p = () => {
+    g(!1), w("");
+  }, x = (e) => {
+    e.disabled || (a(e.value), p());
+  }, E = (e) => {
+    if (e.key === "Escape") {
+      e.stopPropagation(), p();
+      return;
+    }
+    if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+      if (e.preventDefault(), o.length === 0) return;
+      h((t) => (t + (e.key === "ArrowDown" ? 1 : -1) + o.length) % o.length);
+    } else if (e.key === "Enter") {
+      e.preventDefault();
+      const t = o[Math.min(y, o.length - 1)];
+      t && x(t);
+    }
+  }, I = [...new Set(n.map((e) => e.group ?? ""))].sort((e, t) => e === "" ? -1 : t === "" ? 1 : 0), K = o[Math.min(y, Math.max(o.length - 1, 0))]?.value;
+  return /* @__PURE__ */ c("div", {
+    ref: k,
+    className: "studio-editor-select",
+    onKeyDown: i ? E : void 0,
+    onBlur: (e) => {
+      k.current?.contains(e.relatedTarget) || p();
+    },
+    children: [
+      /* @__PURE__ */ l("button", {
+        type: "button",
+        id: d,
+        role: "combobox",
+        "aria-haspopup": "listbox",
+        "aria-expanded": i,
+        "aria-controls": i ? N : void 0,
+        "aria-invalid": D || void 0,
+        className: "studio-editor-select__trigger",
+        disabled: _,
+        ...j,
+        onClick: () => {
+          g(!i), h(0);
+        },
+        children: v ? v(m) : /* @__PURE__ */ l("span", {
+          className: m ? void 0 : "studio-editor-select__placeholder",
+          children: m?.label ?? C
+        })
+      }),
+      S === !0 && s !== void 0 && !_ && /* @__PURE__ */ l("button", {
+        type: "button",
+        className: "studio-editor-select__clear",
+        "aria-label": A,
+        onClick: () => a(void 0),
+        children: "×"
+      }),
+      i && /* @__PURE__ */ c("div", {
+        className: "studio-editor-select__panel",
+        children: [/* @__PURE__ */ l("input", {
+          type: "search",
+          autoFocus: !0,
+          className: "studio-editor-select__search",
+          "aria-label": b,
+          placeholder: b,
+          value: u,
+          onChange: (e) => {
+            w(e.target.value), h(0);
+          }
+        }), /* @__PURE__ */ c("ul", {
+          id: N,
+          role: "listbox",
+          className: "studio-editor-select__options",
+          children: [n.length === 0 && /* @__PURE__ */ l("li", {
+            className: "studio-editor-select__empty",
+            children: M
+          }), I.map((e) => /* @__PURE__ */ c("li", {
+            role: "presentation",
+            children: [e !== "" && /* @__PURE__ */ l("div", {
+              className: "studio-editor-select__group",
+              children: e
+            }), /* @__PURE__ */ l("ul", {
+              role: "presentation",
+              children: n.filter((t) => (t.group ?? "") === e).map((t) => /* @__PURE__ */ c("li", {
+                role: "option",
+                "aria-selected": t.value === s,
+                "aria-disabled": t.disabled || void 0,
+                className: [
+                  "studio-editor-select__option",
+                  t.value === K ? "studio-editor-select__option--active" : "",
+                  t.value === s ? "studio-editor-select__option--chosen" : ""
+                ].join(" ").trim(),
+                title: t.reason,
+                onMouseDown: (L) => L.preventDefault(),
+                onClick: () => x(t),
+                children: [/* @__PURE__ */ l("span", { children: t.label }), t.disabled && t.reason && /* @__PURE__ */ l("small", { children: t.reason })]
+              }, t.value))
+            })]
+          }, e))]
+        })]
+      })
+    ]
+  });
+};
+export {
+  R as t
+};

package/dist/screen-editor/SelectEditor-BuQPlIyf.js

@@ -0,0 +1,26 @@
+import { n as b, t as p } from "./choiceKeys-DQcUX97p.js";
+import { t as h } from "./SearchableSelect-WUNlC3tk.js";
+import { jsx as m } from "react/jsx-runtime";
+var x = ({ value: i, onChange: c, descriptor: o, context: s, disabled: n, problem: d, id: r }) => {
+  const a = s.strings.editors.select, l = i ?? void 0, t = b(o.choices ?? [], l);
+  return /* @__PURE__ */ m(h, {
+    id: r,
+    options: t.map((e) => ({
+      value: e.key,
+      label: e.label
+    })),
+    value: l === void 0 ? void 0 : p(l),
+    disabled: n,
+    invalid: d !== void 0,
+    placeholder: a.placeholder,
+    searchLabel: a.search,
+    emptyLabel: a.empty,
+    clearLabel: a.clear,
+    clearable: o.constraints?.required !== !0,
+    "aria-labelledby": `${r}-label`,
+    onChange: (e) => c(e === void 0 ? void 0 : t.find((v) => v.key === e)?.value)
+  });
+};
+export {
+  x as SelectEditor
+};

package/dist/screen-editor/SliceEditor-Dle8OlsB.js

@@ -0,0 +1,45 @@
+import { t as m } from "./SearchableSelect-WUNlC3tk.js";
+import { jsx as u } from "react/jsx-runtime";
+function b(t, a, o) {
+  return (t.slices.length > 0 ? t.slices : t.stateChangeSlices.map((e) => ({
+    id: e.id,
+    name: e.name,
+    kind: "StateChange",
+    path: e.origin
+  }))).map((e) => {
+    const l = a === void 0 || a.includes(e.kind);
+    return {
+      value: e.id,
+      label: e.name,
+      group: e.path.join(" › "),
+      ...l ? {} : {
+        disabled: !0,
+        reason: o.slice.notKind(a?.[0] ?? e.kind)
+      }
+    };
+  });
+}
+var g = ({ value: t, onChange: a, descriptor: o, context: e, disabled: l, problem: c, id: s }) => {
+  const r = e.strings.editors, i = b(e.lookups, o.editorOptions?.kinds, r), n = typeof t == "string" && t !== "" ? t : void 0, d = n !== void 0 && !i.some((p) => p.value === n);
+  return /* @__PURE__ */ u(m, {
+    id: s,
+    options: d ? [...i, {
+      value: n,
+      label: n,
+      group: ""
+    }] : i,
+    value: n,
+    disabled: l,
+    invalid: d || c !== void 0,
+    placeholder: r.slice.placeholder,
+    searchLabel: r.select.search,
+    emptyLabel: r.select.empty,
+    clearLabel: r.select.clear,
+    clearable: o.constraints?.required !== !0,
+    "aria-labelledby": `${s}-label`,
+    onChange: a
+  });
+};
+export {
+  g as SliceEditor
+};

package/dist/screen-editor/StateChangeEditors-9k3Gqtc0.js

@@ -0,0 +1,15 @@
+import { SliceEditor as r } from "./SliceEditor-Dle8OlsB.js";
+import { jsx as i } from "react/jsx-runtime";
+var d = (t) => /* @__PURE__ */ i(r, {
+  ...t,
+  descriptor: {
+    ...t.descriptor,
+    editorOptions: {
+      kinds: ["StateChange"],
+      ...t.descriptor.editorOptions
+    }
+  }
+});
+export {
+  d as StateChangeEditor
+};

package/dist/screen-editor/StructuredPropertyEditor-B3lVjrHZ.js

@@ -0,0 +1,13 @@
+import { t as s } from "./StructuredValueEditor-CcwyOga0.js";
+import { jsx as u } from "react/jsx-runtime";
+var p = ({ value: r, onChange: t, descriptor: e, context: i, disabled: d, id: o }) => /* @__PURE__ */ u(s, {
+  descriptor: e,
+  value: r,
+  idPrefix: o,
+  strings: i.strings.structured,
+  disabled: d === !0,
+  onChange: t
+});
+export {
+  p as StructuredPropertyEditor
+};