@cratis/event-models 0.175.0 → 0.177.0

package/dist/screen-editor/ScreenEditor/Palette/ComponentPicker.d.ts

@@ -0,0 +1,21 @@
+import { type PickerEntry } from './componentPickerModel';
+import type { ComponentPickerMemory } from './componentPickerStorage';
+export interface ComponentPickerStrings {
+    heading: string;
+    filterPlaceholder: string;
+    filterLabel: string;
+    frequentlyUsed: string;
+    groupsHint: string;
+    nothingMatches: string;
+    viaKeyword: (badge: string, query: string, keyword: string) => string;
+    addLabel: (component: string) => string;
+}
+export declare const defaultComponentPickerStrings: ComponentPickerStrings;
+export interface ComponentPickerProps {
+    entries: readonly PickerEntry[];
+    memory: ComponentPickerMemory;
+    strings?: ComponentPickerStrings;
+    onAdd: (entry: PickerEntry) => void;
+    usageVersion?: number;
+}
+export declare const ComponentPicker: ({ entries, memory, strings, onAdd, usageVersion }: ComponentPickerProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Palette/PaletteFolders.d.ts

@@ -1,7 +1,15 @@
-import type { PaletteDrawer } from './buildPalette';
+import type { ReactNode } from 'react';
+import { type ComponentPickerStrings } from './ComponentPicker';
+import type { PickerEntry } from './componentPickerModel';
+import type { ComponentPickerMemory } from './componentPickerStorage';
 export interface PaletteFoldersProps {
-    drawers: readonly PaletteDrawer[];
+    entries: readonly PickerEntry[];
+    memory: ComponentPickerMemory;
+    icon: ReactNode;
+    title: string;
     closeLabel: string;
-    onActivate: (payload: unknown) => void;
+    strings?: ComponentPickerStrings;
+    usageVersion: number;
+    onAdd: (entry: PickerEntry) => void;
 }
-export declare const PaletteFolders: ({ drawers, closeLabel, onActivate }: PaletteFoldersProps) => import("react").JSX.Element;
+export declare const PaletteFolders: ({ entries, memory, icon, title, closeLabel, strings, usageVersion, onAdd }: PaletteFoldersProps) => import("react").JSX.Element;

package/dist/screen-editor/ScreenEditor/Palette/buildPalette.d.ts

@@ -1,16 +1,10 @@
-import type { ToolbarDrawerItem } from '@cratis/components/Toolbar';
+import type { ComponentDescriptor } from '@cratis/scene.model';
 import type { ReactNode } from 'react';
-import type { LayoutLabels } from '../Layouts/toLayoutContainerDescriptors';
 import type { LayoutItem } from '../Layouts/LayoutItem';
-export interface PaletteDrawer {
-    id: string;
-    title: string;
-    icon: ReactNode;
-    items: ToolbarDrawerItem[];
-}
 export interface PaletteSource {
     package: string;
     components: readonly string[];
+    descriptors?: readonly ComponentDescriptor[];
 }
 export interface PaletteIcons {
     layout: (item: LayoutItem) => ReactNode;
@@ -20,4 +14,3 @@ export interface PaletteIcons {
         package: (packageName: string) => ReactNode;
     };
 }
-export declare function buildPalette(layoutTitle: string, labels: LayoutLabels, icons: PaletteIcons, sources: readonly PaletteSource[], packageTitles?: Readonly<Record<string, string>>): PaletteDrawer[];

package/dist/screen-editor/ScreenEditor/Palette/componentPickerModel.d.ts

@@ -0,0 +1,54 @@
+import { type ComponentQueryMatch, type ComponentUsage } from '@cratis/scene.engine';
+import { type ComponentDescriptor } from '@cratis/scene.model';
+import type { PalettePayload } from './PaletteEntry';
+export interface PickerEntry {
+    key: string;
+    label: string;
+    badge: string;
+    category: string;
+    keywords: readonly string[];
+    package?: string;
+    packageTitle?: string;
+    payload: PalettePayload;
+}
+export interface PickerSource {
+    package: string;
+    components: readonly string[];
+    descriptors?: readonly ComponentDescriptor[];
+}
+export interface PickerLayout {
+    item: string;
+    label: string;
+}
+export declare const uncategorised = "Other";
+export declare const layoutCategory: "Layout";
+export declare function buildPickerEntries(sources: readonly PickerSource[], layouts: readonly PickerLayout[], packageTitles?: Readonly<Record<string, string>>): PickerEntry[];
+export interface PickerRow {
+    entry: PickerEntry;
+    match: ComponentQueryMatch;
+}
+export interface PickerGroup {
+    id: string;
+    title: string;
+    frequent: boolean;
+    count: number;
+    expanded: boolean;
+    rows: PickerRow[];
+}
+export interface PickerViewInputs {
+    entries: readonly PickerEntry[];
+    usage: Readonly<Record<string, ComponentUsage>>;
+    query: string;
+    groups: Readonly<Record<string, boolean>>;
+    frequentTitle: string;
+}
+export declare const frequentGroupId = "frequent";
+export declare function buildPickerView({ entries, usage, query, groups, frequentTitle }: PickerViewInputs): PickerGroup[];
+export declare const visibleRows: (view: readonly PickerGroup[]) => {
+    group: PickerGroup;
+    row: PickerRow;
+}[];
+export declare function highlightParts(text: string, ranges: readonly [number, number][]): {
+    text: string;
+    marked: boolean;
+}[];

package/dist/screen-editor/ScreenEditor/Palette/componentPickerStorage.d.ts

@@ -0,0 +1,15 @@
+import { type ComponentUsage } from '@cratis/scene.engine';
+export declare const componentUsageKey = "cratis.studio.componentUsage.v1";
+export declare const componentGroupsKey = "cratis.studio.componentGroups.v1";
+export interface ComponentPickerStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export interface ComponentPickerMemory {
+    readUsage(): Record<string, ComponentUsage>;
+    recordAdded(key: string, now?: number): Record<string, ComponentUsage>;
+    readGroups(): Record<string, boolean>;
+    writeGroups(groups: Readonly<Record<string, boolean>>): void;
+}
+export declare const browserComponentPickerStorage: () => ComponentPickerStorage | undefined;
+export declare function createComponentPickerMemory(storage?: ComponentPickerStorage | undefined, userId?: string): ComponentPickerMemory;

package/dist/screen-editor/ScreenEditor/Palette/useComponentPalette.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from 'react';
+import type { LayoutLabels } from '../Layouts/toLayoutContainerDescriptors';
+import type { ScreenEditorStrings } from '../Inspector/ScreenEditorStrings';
+import type { PaletteIcons, PaletteSource } from './buildPalette';
+import { type PickerEntry } from './componentPickerModel';
+import { type ComponentPickerMemory } from './componentPickerStorage';
+export interface ComponentPaletteInputs {
+    strings: ScreenEditorStrings;
+    layoutLabels: LayoutLabels;
+    icons: PaletteIcons;
+    paletteSources: readonly PaletteSource[];
+    onAdd: (entry: PickerEntry) => void;
+    memory?: ComponentPickerMemory;
+}
+export declare function useComponentPalette({ strings, layoutLabels, icons, paletteSources, onAdd, memory: given }: ComponentPaletteInputs): {
+    palette: ReactNode;
+    recordInserted: (key: string) => void;
+};

package/dist/screen-editor/ScreenEditor/Properties/choiceKeys.d.ts

@@ -4,3 +4,12 @@ export declare const selectedChoiceKey: (value: unknown) => string;
 export declare function choiceValueOf(property: InspectedProperty, key: unknown): {
     value: unknown;
 } | undefined;
+export interface ChoiceOption {
+    key: string;
+    label: string;
+    value: unknown;
+}
+export declare function choiceOptions(choices: readonly {
+    value: unknown;
+    label: string;
+}[], stored: unknown): ChoiceOption[];

package/dist/screen-editor/ScreenEditor/Properties/toPropertyGroups.d.ts

@@ -1,9 +1,8 @@
 import { type InspectedProperty } from '@cratis/scene.model';
-import type { PropertyDescriptor as ControlDescriptor, PropertyGroup } from '@cratis/components/ConfigurationEditor';
-export declare const isSimpleProperty: (property: InspectedProperty) => boolean;
 export declare const isDrawnByItsOwnEditor: (typeId: string, path: string) => boolean;
-export declare function toControlDescriptor(property: InspectedProperty): ControlDescriptor;
-export declare function toPropertyGroups(properties: readonly InspectedProperty[], typeId?: string): {
-    groups: PropertyGroup[];
-    values: Record<string, unknown>;
-};
+export declare const editableProperties: (properties: readonly InspectedProperty[], typeId: string, isDrawnElsewhere?: (property: InspectedProperty) => boolean) => InspectedProperty[];
+export interface PropertyGroup {
+    name: string;
+    properties: InspectedProperty[];
+}
+export declare function groupProperties(properties: readonly InspectedProperty[]): PropertyGroup[];

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

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

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

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

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';