@cratis/event-models 0.0.0-stage → 0.105.6

package/dist/Collections/CollectionGridFeature.d.ts

@@ -0,0 +1,19 @@
+import { type Ref } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { type FeaturesAreaHandle } from '../Features';
+import { type Feature, type ModuleCollection } from '../Model';
+import { RowType } from '../Rows';
+import type { CollectionGridSlots } from './CollectionGridSlots';
+import type { CollectionGridEditor } from './CollectionGridEditor';
+export interface CollectionGridFeatureProps {
+    ref?: Ref<FeaturesAreaHandle<Feature>>;
+    moduleId: Guid;
+    collection: ModuleCollection;
+    features: Feature[];
+    rows: RowType[];
+    heights: Record<RowType, number>;
+    slots?: CollectionGridSlots;
+    editor: CollectionGridEditor;
+    onFeaturesChanged?: (features: Feature[]) => void;
+}
+export declare const CollectionGridFeature: ({ ref, moduleId, collection, features, rows, heights, slots, editor, onFeaturesChanged }: CollectionGridFeatureProps) => import("react").JSX.Element;

package/dist/Collections/CollectionGridFeatureColumn.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { type FeaturesAreaProps } from '../Features';
+import { type SlicesAreaHandle } from '../Slices';
+import { type EventItem, type Feature, type ModuleCollection, type Slice } from '../Model';
+import { RowType } from '../Rows';
+import type { CollectionGridSlots } from './CollectionGridSlots';
+import type { CollectionGridEditor } from './CollectionGridEditor';
+import type { CollectionGridFeatureHeaderControls } from './CollectionGridFeatureHeaderControls';
+export interface CollectionGridFeatureColumnProps {
+    feature: Feature;
+    options: Parameters<FeaturesAreaProps<Feature>['renderColumn']>[1];
+    moduleId: Guid;
+    collection: ModuleCollection;
+    rows: RowType[];
+    heights: Record<RowType, number>;
+    slices: Slice[];
+    externalEvents: EventItem[];
+    slots?: CollectionGridSlots;
+    editor: CollectionGridEditor;
+    onSliceArea: (handle: SlicesAreaHandle<Slice> | null) => void;
+    sliceAreas: ReadonlyMap<string, SlicesAreaHandle<Slice>>;
+    renderHeader: (controls: CollectionGridFeatureHeaderControls) => ReactNode;
+    onSlicesChanged?: (slices: Slice[]) => void;
+}
+export declare const CollectionGridFeatureColumn: ({ feature, options, moduleId, collection, rows, heights, slices, externalEvents, slots, editor, onSliceArea, sliceAreas, renderHeader, onSlicesChanged }: CollectionGridFeatureColumnProps) => import("react").JSX.Element;

package/dist/Collections/CollectionGridFeatureHeaderControls.d.ts

@@ -0,0 +1,13 @@
+import type { HeaderDragStart } from '../HeaderDragging';
+import type { SliceType } from '../Model';
+import type { SliceNames } from '../Slices';
+export interface CollectionGridFeatureHeaderControls {
+    collapsed: boolean;
+    dragging: boolean;
+    onDragStart?: (start: HeaderDragStart) => void;
+    onAddSubFeature?: (name?: string) => void;
+    onAddSlice?: (sliceType: SliceType, names?: SliceNames) => void;
+    onRenamed?: (name: string) => void;
+    onToggleCollapse?: () => void;
+    onCollapseFailed?: () => void;
+}

package/dist/Collections/CollectionGridModule.d.ts

@@ -0,0 +1,23 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Feature, Module, ModuleCollection } from '../Model';
+import { RowType } from '../Rows';
+import type { CollectionGridSlots } from './CollectionGridSlots';
+import type { CollectionGridEditor } from './CollectionGridEditor';
+import type { HeaderDragStart } from '../HeaderDragging';
+export interface CollectionGridModuleProps {
+    module: Module;
+    liveFeatures?: Feature[];
+    index: number;
+    collection: ModuleCollection;
+    rows: RowType[];
+    heights: Record<RowType, number>;
+    slots?: CollectionGridSlots;
+    editor: CollectionGridEditor;
+    dragging?: boolean;
+    onDragStart?: (start: HeaderDragStart) => void;
+    onAddModule?: () => void;
+    onToggleCollapse?: () => void;
+    onRenamed?: (name: string) => void;
+    onFeaturesChanged?: (moduleId: Guid, features: Feature[]) => void;
+}
+export declare const CollectionGridModule: ({ module, liveFeatures, index, collection, rows, heights, slots, editor, dragging, onDragStart, onAddModule, onToggleCollapse, onRenamed, onFeaturesChanged }: CollectionGridModuleProps) => string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;

package/dist/Collections/CollectionGridModuleHeaderControls.d.ts

@@ -0,0 +1,8 @@
+import type { HeaderDragStart } from '../HeaderDragging';
+export interface CollectionGridModuleHeaderControls {
+    onDragStart?: (start: HeaderDragStart) => void;
+    onAddModule?: () => void;
+    onAddFeature?: (name?: string) => void;
+    onToggleCollapse?: () => void;
+    onRenamed?: (name: string) => void;
+}

package/dist/Collections/CollectionGridSlice.d.ts

@@ -0,0 +1,19 @@
+import { type EventItem, type Slice } from '../Model';
+import { RowType } from '../Rows';
+import type { Feature, Module, ModuleCollection } from '../Model';
+import type { CollectionGridSlots } from './CollectionGridSlots';
+import type { CollectionGridSliceHeaderControls } from './CollectionGridSliceHeaderControls';
+export interface CollectionGridSliceProps {
+    slice: Slice;
+    collapsed: boolean;
+    moduleId: Module['id'];
+    featureId: Feature['id'];
+    collection: ModuleCollection;
+    rows: RowType[];
+    heights: Record<RowType, number>;
+    priorEvents: EventItem[];
+    externalEvents: EventItem[];
+    slots?: CollectionGridSlots;
+    controls?: CollectionGridSliceHeaderControls;
+}
+export declare const CollectionGridSlice: ({ slice, collapsed, moduleId, featureId, collection, rows, heights, priorEvents, externalEvents, slots, controls }: CollectionGridSliceProps) => string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | Iterable<import("react").ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;

package/dist/Collections/CollectionGridSliceHeaderControls.d.ts

@@ -0,0 +1,14 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceType } from '../Model';
+import type { SliceDragStartHandler } from '../SliceDragging';
+export interface CollectionGridSliceHeaderControls {
+    collapsed: boolean;
+    sliceCollapsed: boolean;
+    isDragging: boolean;
+    onSliceDragStart?: SliceDragStartHandler;
+    onAddSlice?: (sliceType: SliceType, afterSliceId?: Guid) => void;
+    onToggleCollapse?: () => void;
+    onRenamed?: (name: string) => void;
+    onMoveToFeature?: (targetFeatureId: Guid) => void;
+    onDuplicated?: (newSliceId: Guid) => void;
+}

package/dist/Collections/CollectionGridSlots.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+import type { Feature, Module, Slice } from '../Model';
+import type { SliceRowCell } from '../Slices';
+import type { Actor } from '../Model';
+import type { CollectionGridModuleHeaderControls } from './CollectionGridModuleHeaderControls';
+import type { CollectionGridFeatureHeaderControls } from './CollectionGridFeatureHeaderControls';
+import type { CollectionGridSliceHeaderControls } from './CollectionGridSliceHeaderControls';
+export interface CollectionGridSlots {
+    moduleBoundary?: (module: Module, children: ReactNode) => ReactNode;
+    featureBoundary?: (feature: Feature, children: ReactNode) => ReactNode;
+    sliceBoundary?: (slice: Slice, children: ReactNode) => ReactNode;
+    moduleHeader?: (module: Module, controls: CollectionGridModuleHeaderControls) => ReactNode;
+    moduleTemplate?: (module: Module, width: number) => ReactNode;
+    featureHeader?: (feature: Feature, controls: CollectionGridFeatureHeaderControls) => ReactNode;
+    featureTemplate?: (feature: Feature, width: number) => ReactNode;
+    sliceHeader?: (slice: Slice, controls: CollectionGridSliceHeaderControls) => ReactNode;
+    sliceCell?: (slice: Slice, cell: SliceRowCell<Actor>) => ReactNode | undefined;
+    sliceBodyOverlay?: (slice: Slice, collapsed: boolean) => ReactNode;
+    specifications?: (slice: Slice, inView: boolean, specificationsWidth: number, sliceCollapsed: boolean) => ReactNode;
+}

package/dist/Collections/CollectionGridTemplate.d.ts

@@ -0,0 +1,6 @@
+import type { ScreenTemplate } from '../Model';
+export interface CollectionGridTemplateProps {
+    template: ScreenTemplate;
+    width: number;
+}
+export declare const CollectionGridTemplate: ({ template, width }: CollectionGridTemplateProps) => import("react").JSX.Element;

package/dist/Collections/CollectionMoveHandle.d.ts

@@ -0,0 +1,12 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Position } from '../Model';
+import type { CollectionMoved, CollectionMoving } from './CollectionMoved';
+export interface CollectionMoveHandleProps {
+    collectionId: Guid;
+    position: Position;
+    getZoom: () => number;
+    topOffset?: number;
+    onCollectionMoving?: CollectionMoving;
+    onCollectionMoved?: CollectionMoved;
+}
+export declare const CollectionMoveHandle: ({ onCollectionMoved, ...props }: CollectionMoveHandleProps) => import("react").JSX.Element | undefined;

package/dist/Collections/CollectionMoved.d.ts

@@ -0,0 +1,4 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Position } from '../Model';
+export type CollectionMoved = (collectionId: Guid, position: Position) => void;
+export type CollectionMoving = (collectionId: Guid, deltaX: number, deltaY: number) => void;

package/dist/Collections/CollectionViewport.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { CollectionItem } from './collectionState';
+interface CollectionModule {
+    id: Guid;
+    name: string;
+}
+interface ViewportCollection extends CollectionItem {
+    modules: CollectionModule[];
+}
+export interface CollectionViewportProps<T extends ViewportCollection> {
+    collection: T;
+    estimatedSize: {
+        width: number;
+        height: number;
+        moduleWidths: number[];
+    };
+    measuredSize?: {
+        width: number;
+        height: number;
+    };
+    onSize?: (id: Guid, width: number, height: number) => void;
+    children: ReactNode;
+}
+declare function Viewport<T extends ViewportCollection>({ collection, estimatedSize, measuredSize, onSize, children }: CollectionViewportProps<T>): import("react").JSX.Element;
+export declare const CollectionViewport: import("react").MemoExoticComponent<typeof Viewport>;
+export {};

package/dist/Collections/collectionGridLayout.d.ts

@@ -0,0 +1,11 @@
+import { type Feature, type ModuleCollection, type Slice } from '../Model';
+import { RowType } from '../Rows';
+export declare const collectionSlices: (collection: ModuleCollection) => {
+    slice: Slice;
+}[];
+export declare const collectionRows: (collection: ModuleCollection) => RowType[];
+export declare const collectionRowHeights: (collection: ModuleCollection) => Record<RowType, number>;
+export declare const collectionContentHeight: (collection: ModuleCollection, rows: readonly RowType[], heights: Readonly<Record<RowType, number>>) => number;
+export declare const featureWidth: (feature: Feature) => number;
+export declare const featureColumns: (features: Feature[]) => Feature[];
+export declare const collectionModuleWidth: (name: string, features: Feature[]) => number;

package/dist/Collections/collectionState.d.ts

@@ -0,0 +1,24 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Position } from '../Model';
+export interface CollectionItem {
+    id: Guid;
+    position: Position;
+}
+export interface CollectionState<T extends CollectionItem> {
+    snapshot: T[];
+    collections: T[];
+    additions: T[];
+    locallyMovedAt: ReadonlyMap<string, number>;
+    pendingMoveIds: ReadonlySet<string>;
+    contentSignature: string;
+}
+export declare const collectionContentSignature: (collections: readonly CollectionItem[]) => string;
+export declare function createCollectionState<T extends CollectionItem>(snapshot: T[]): CollectionState<T>;
+export declare function reconcileCollections<T extends CollectionItem>(state: CollectionState<T>, snapshot: T[], now: number): CollectionState<T>;
+export declare function revertCollectionMove<T extends CollectionItem>(state: CollectionState<T>, id: Guid): CollectionState<T>;
+export declare function beginCollectionMovePersistence<T extends CollectionItem>(state: CollectionState<T>, id: Guid): CollectionState<T>;
+export declare function endCollectionMovePersistence<T extends CollectionItem>(state: CollectionState<T>, id: Guid): CollectionState<T>;
+export declare function moveCollection<T extends CollectionItem>(state: CollectionState<T>, id: Guid, deltaX: number, deltaY: number, now: number): CollectionState<T>;
+export declare const OVERLAP_STEP = 48;
+export declare const SAME_SPOT_TOLERANCE = 0.5;
+export declare function resolveOverlappingCollections<T extends CollectionItem>(collections: T[]): T[];

package/dist/Collections/estimateCollectionSize.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleCollection } from '../Model';
+export interface CollectionSizeEstimate {
+    width: number;
+    height: number;
+    moduleWidths: number[];
+}
+export declare const estimateCollectionSize: (collection: ModuleCollection) => CollectionSizeEstimate;

package/dist/Collections/index.d.ts

@@ -0,0 +1,13 @@
+export * from './CollectionMoved';
+export * from './CollectionMoveHandle';
+export * from './useCollectionMove';
+export * from './collectionState';
+export * from './useCollectionsArea';
+export * from './CollectionViewport';
+export * from './estimateCollectionSize';
+export * from './CollectionGrid';
+export * from './CollectionGridSlots';
+export * from './CollectionGridEditor';
+export * from './CollectionGridModuleHeaderControls';
+export * from './CollectionGridFeatureHeaderControls';
+export * from './CollectionGridSliceHeaderControls';

package/dist/Collections/useCollectionMove.d.ts

@@ -0,0 +1,10 @@
+import { type PointerEvent } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { Position } from '../Model';
+import type { CollectionMoved, CollectionMoving } from './CollectionMoved';
+export interface CollectionMoveHandlers {
+    onPointerDown: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerMove: (event: PointerEvent<HTMLDivElement>) => void;
+    onPointerUp: () => void;
+}
+export declare function useCollectionMove(collectionId: Guid, position: Position, getZoom: () => number, onCollectionMoving?: CollectionMoving, onCollectionMoved?: CollectionMoved): CollectionMoveHandlers;

package/dist/Collections/useCollectionsArea.d.ts

@@ -0,0 +1,27 @@
+import { type SetStateAction } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { type CollectionItem } from './collectionState';
+export interface CollectionsAreaOptions<T extends CollectionItem> {
+    initialCollections: T[];
+    onAddCollection?: (x: number, y: number, collections: T[]) => Promise<T | undefined>;
+    onCollectionMoved?: (id: Guid, position: {
+        x: number;
+        y: number;
+    }) => Promise<boolean>;
+    onCollectionsChange?: (collections: T[]) => void;
+    onPersistenceError?: (error: unknown) => void;
+}
+export interface CollectionsArea<T extends CollectionItem> {
+    collections: T[];
+    pendingMoveIds: ReadonlySet<string>;
+    setCollections: (updater: SetStateAction<T[]>) => void;
+    addCollection: (x: number, y: number) => Promise<void>;
+    moveCollection: (id: Guid, deltaX: number, deltaY: number) => void;
+    collectionMoved: (id: Guid, position: {
+        x: number;
+        y: number;
+    }) => Promise<void>;
+    canMove: boolean;
+    canAdd: boolean;
+}
+export declare function useCollectionsArea<T extends CollectionItem>({ initialCollections, onAddCollection, onCollectionMoved, onCollectionsChange, onPersistenceError, }: CollectionsAreaOptions<T>): CollectionsArea<T>;

package/dist/Connections/Connectors.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { SliceType } from '../Model';
+import { RowType } from '../Rows';
+export interface ConnectorProps {
+    /**
+     * Override the horizontal center of the connector arrow/fill-line.
+     * 'left' = 25% (read-model column), 'center' = 50% (default), 'right' = 75% (command column).
+     */
+    columnPosition?: 'left' | 'center' | 'right';
+}
+export declare const ConnectorIncomingTop: React.FC<ConnectorProps>;
+export declare const ConnectorOutgoingTop: React.FC<ConnectorProps>;
+export declare const PassthroughConnector: React.FC<ConnectorProps>;
+export declare const ConnectorOutgoingBottom: React.FC<ConnectorProps>;
+export declare const ConnectorIncomingBottom: React.FC<ConnectorProps>;
+export interface CellConnectors {
+    bottomOutgoing?: boolean;
+    topIncoming?: boolean;
+    topOutgoing?: boolean;
+    bottomIncoming?: boolean;
+    passthrough?: boolean;
+}
+export declare function cellConnectors(rowType: RowType, sliceType: SliceType, contentRows?: RowType[]): CellConnectors;

package/dist/Connections/FlowNodeActor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Identifies the role a card plays in a slice's flow, used to anchor the curved
+ * connection lines drawn in the "lines" visualization mode. The string values
+ * are emitted as the `data-flow-node` attribute on the corresponding card element.
+ */
+export declare enum FlowNodeActor {
+    ui = "ui",
+    command = "command",
+    readModel = "readModel",
+    cogwheel = "cogwheel",
+    event = "event",
+    externalEvent = "externalEvent"
+}

package/dist/Connections/SliceConnections.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { SliceType } from '../Model';
+export interface SliceConnectionsProps {
+    sliceType: SliceType;
+    recomputeKey: string;
+}
+export declare const SliceConnections: React.FC<SliceConnectionsProps>;

package/dist/Connections/SliceConnectionsContext.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { SliceConnection } from './computeSliceConnections';
+export interface SliceConnectionsContextValue {
+    getConnection: (sliceId: string) => SliceConnection | undefined;
+}
+export interface SliceConnectionsProviderProps {
+    connections: Map<string, SliceConnection>;
+    children: React.ReactNode;
+}
+export declare const SliceConnectionsProvider: ({ connections, children }: SliceConnectionsProviderProps) => React.JSX.Element;
+export declare const useSliceConnection: (sliceId: string) => SliceConnection | undefined;

package/dist/Connections/computeSliceConnections.d.ts

@@ -0,0 +1,23 @@
+export interface ConnectionEvent {
+    id: string;
+    name: string;
+    sourceEventId?: string;
+}
+export interface ConnectionSlice {
+    id: string;
+    name: string;
+    events: ConnectionEvent[];
+    automationTriggerEventId?: string;
+}
+export interface SliceConnectionLink {
+    eventId: string;
+    eventName: string;
+    sliceId: string;
+    sliceName: string;
+}
+export interface SliceConnection {
+    connectedSliceIds: ReadonlySet<string>;
+    consumed: SliceConnectionLink[];
+    produced: SliceConnectionLink[];
+}
+export declare function computeSliceConnections(slices: readonly ConnectionSlice[]): Map<string, SliceConnection>;

package/dist/Connections/flowNodeOrder.d.ts

@@ -0,0 +1,3 @@
+import { SliceType } from '../Model';
+import { FlowNodeActor } from './FlowNodeActor';
+export declare function flowNodeOrder(sliceType: SliceType): FlowNodeActor[];

package/dist/Connections/index.d.ts

@@ -0,0 +1,7 @@
+export * from './Connectors';
+export * from './FlowNodeActor';
+export * from './computeSliceConnections';
+export * from './SliceConnections';
+export * from './SliceConnectionsContext';
+export * from './useConnectionHighlight';
+export * from './flowNodeOrder';

package/dist/Connections/useConnectionHighlight.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+export interface ConnectionHighlight {
+    ref: React.RefObject<HTMLDivElement | null>;
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+}
+export declare function useConnectionHighlight(connectedSliceIds: ReadonlySet<string> | undefined): ConnectionHighlight;

package/dist/Features/FeatureAddMenu.d.ts

@@ -0,0 +1,10 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceType } from '../Model';
+import type { FeatureHeaderMenuAction } from './FeatureHeaderMenuAction';
+export interface FeatureAddMenuProps {
+    featureId: Guid;
+    onAddSubFeature?: () => void;
+    onAddSlice?: (sliceType: SliceType) => void;
+    actions?: readonly FeatureHeaderMenuAction[];
+}
+export declare const FeatureAddMenu: ({ featureId, onAddSubFeature, onAddSlice, actions }: FeatureAddMenuProps) => import("react").JSX.Element | null;

package/dist/Features/FeatureColumnFrame.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface FeatureColumnFrameProps {
+    featureId: Guid;
+    moduleId: Guid;
+    enabled: boolean;
+    dragging?: boolean;
+    children?: ReactNode;
+}
+export declare const FeatureColumnFrame: ({ featureId, moduleId, enabled, dragging, children }: FeatureColumnFrameProps) => import("react").JSX.Element;

package/dist/Features/FeatureGridSurface.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface FeatureGridSurfaceProps {
+    featureId: Guid;
+    moduleId: Guid;
+    enabled: boolean;
+    collapsed: boolean;
+    rowCollapsed: boolean;
+    width: number;
+    headerVisibility: 'visible' | 'hidden' | 'none';
+    header: ReactNode;
+    screenTemplate?: ReactNode;
+    slices: ReactNode;
+}
+export declare const FeatureGridSurface: ({ featureId, moduleId, enabled, collapsed, rowCollapsed, width, headerVisibility, header, screenTemplate, slices }: FeatureGridSurfaceProps) => import("react").JSX.Element;

package/dist/Features/FeatureHeader.d.ts

@@ -0,0 +1,21 @@
+import type { SliceType } from '../Model';
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceStatus } from '../Model';
+import { type HeaderDragStart } from '../HeaderDragging';
+export interface FeatureHeaderProps {
+    featureId: Guid;
+    name: string;
+    height: number;
+    collapsed: boolean;
+    onToggleCollapse?: () => void;
+    onRenamed?: (featureId: Guid, name: string) => void;
+    status?: SliceStatus;
+    detailsVisible?: boolean;
+    onToggleDetails?: () => void;
+    dragging?: boolean;
+    onDragStart?: (start: HeaderDragStart) => void;
+    error?: string;
+    onAddSubFeature?: () => void;
+    onAddSlice?: (sliceType: SliceType) => void;
+}
+export declare const FeatureHeader: ({ featureId, name, height, collapsed, onToggleCollapse, onRenamed, status, detailsVisible, onToggleDetails, dragging, onDragStart, error, onAddSubFeature, onAddSlice, }: FeatureHeaderProps) => import("react").JSX.Element;

package/dist/Features/FeatureHeaderAction.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface FeatureHeaderAction {
+    icon: ReactNode;
+    tooltip: string;
+    when?: (featureId: Guid) => boolean;
+    disabled?: boolean;
+    disabledTooltip?: string;
+    active?: boolean;
+    indicator?: boolean;
+    onActivate: (featureId: Guid, host: DOMRect) => void;
+}

package/dist/Features/FeatureHeaderCell.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode, Ref } from 'react';
+import type { FeatureDropEdge } from './featureDropEdge';
+export interface FeatureHeaderCellProps {
+    width: number;
+    collapsed: boolean;
+    dropEdge?: FeatureDropEdge;
+    children?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare const FeatureHeaderCell: ({ width, collapsed, dropEdge, children, ref }: FeatureHeaderCellProps) => import("react").JSX.Element;

package/dist/Features/FeatureHeaderMenu.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { FeatureHeaderMenuAction } from './FeatureHeaderMenuAction';
+export interface FeatureHeaderMenuProps {
+    featureId: Guid;
+    tooltip: string;
+    icon: ReactNode;
+    actions: readonly FeatureHeaderMenuAction[];
+}
+export declare const FeatureHeaderMenu: ({ featureId, tooltip, icon, actions }: FeatureHeaderMenuProps) => import("react").JSX.Element | null;

package/dist/Features/FeatureHeaderMenuAction.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+export interface FeatureHeaderMenuAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    description?: string;
+    disabled?: boolean;
+    tooltip?: string;
+    isSeparator?: boolean;
+    when?: (featureId: Guid) => boolean;
+    onActivate: (featureId: Guid, host: DOMRect) => void;
+    items?: readonly FeatureHeaderMenuAction[];
+}

package/dist/Features/FeatureHeaderSuggestion.d.ts

@@ -0,0 +1,9 @@
+export interface FeatureHeaderSuggestion {
+    id: string;
+    name: string;
+    acceptLabel: string;
+    discardLabel: string;
+    rationale?: string;
+    onAccept: () => Promise<void>;
+    onDiscard: () => void;
+}

package/dist/Features/FeatureSuggestions.d.ts

@@ -0,0 +1,4 @@
+import type { FeatureHeaderSuggestion } from './FeatureHeaderSuggestion';
+export declare const FeatureSuggestions: ({ suggestions }: {
+    suggestions: readonly FeatureHeaderSuggestion[];
+}) => import("react").JSX.Element;

package/dist/Features/FeaturesArea.d.ts

@@ -0,0 +1,42 @@
+import { type ReactNode, type Ref } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { useFeatureDrag } from './useFeatureDrag';
+import { type FeatureAreaItem } from './featureAreaState';
+export interface FeaturesAreaHandle<T> {
+    addFeature: (name?: string) => Promise<void>;
+    addSubFeature: (parentId: Guid, name?: string) => Promise<void>;
+    updateFeature: (id: Guid, update: (feature: T) => T) => void;
+}
+export interface FeaturesAreaProps<T extends FeatureAreaItem<T>> {
+    ref?: Ref<FeaturesAreaHandle<T>>;
+    initialFeatures: T[];
+    moduleId: Guid;
+    widthOf: (feature: T) => number;
+    isCollapsed: (feature: T) => boolean;
+    forceCollapsed?: boolean;
+    onCollapseChanged?: (featureId: Guid, collapsed: boolean) => void;
+    occupiesColumn: (feature: T) => boolean;
+    renderHeader: (feature: T, options: {
+        collapsed: boolean;
+        dragging: boolean;
+        onDragStart?: NonNullable<ReturnType<typeof useFeatureDrag>['handleFeatureDragStart']>;
+        addSubFeature?: (name?: string) => void;
+        onRenamed?: (name: string) => void;
+        onToggleCollapse?: () => void;
+        onCollapseFailed?: () => void;
+    }) => ReactNode;
+    renderColumn: (feature: T, options: {
+        headerVisibility: 'visible' | 'hidden' | 'none';
+        addSubFeature?: (name?: string) => void;
+        onRenamed?: (name: string) => void;
+        onToggleCollapse?: () => void;
+        onCollapseFailed?: () => void;
+        collapsed: boolean;
+    }) => ReactNode;
+    renderFeatureBoundary?: (feature: T, content: ReactNode) => ReactNode;
+    onAddFeature?: (name?: string, parentId?: Guid) => Promise<T | undefined>;
+    onRenameFeature?: (featureId: Guid, name: string) => Promise<void>;
+    onFeaturesReordered?: (features: T[]) => void;
+    onFeaturesChanged?: (features: T[]) => void;
+}
+export declare function FeaturesArea<T extends FeatureAreaItem<T>>({ ref, initialFeatures, moduleId, widthOf, isCollapsed, forceCollapsed, onCollapseChanged, occupiesColumn, renderHeader, renderColumn, renderFeatureBoundary, onAddFeature, onRenameFeature, onFeaturesReordered, onFeaturesChanged, }: FeaturesAreaProps<T>): import("react").JSX.Element;

package/dist/Features/FeaturesReordered.d.ts

@@ -0,0 +1,2 @@
+import type { Guid } from '@cratis/fundamentals';
+export type FeaturesReordered = (moduleId: Guid, orderedIds: Guid[]) => void;

package/dist/Features/featureAreaState.d.ts

@@ -0,0 +1,27 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface FeatureAreaItem<T> {
+    id: Guid;
+    subFeatures: T[];
+    name: string;
+    collapsed: boolean;
+}
+export interface FeatureAreaState<T extends FeatureAreaItem<T>> {
+    snapshot: T[];
+    features: T[];
+    pendingAdditions: {
+        feature: T;
+        parentId?: Guid;
+    }[];
+    order?: Guid[];
+    pendingRenames: ReadonlyMap<string, string>;
+    pendingCollapses: ReadonlyMap<string, boolean>;
+}
+export declare const createFeatureAreaState: <T extends FeatureAreaItem<T>>(features: T[]) => FeatureAreaState<T>;
+export declare function updateFeature<T extends FeatureAreaItem<T>>(features: T[], id: Guid, update: (feature: T) => T): T[];
+export declare function insertFeature<T extends FeatureAreaItem<T>>(features: T[], feature: T, parentId?: Guid): T[];
+export declare function reconcileFeatures<T extends FeatureAreaItem<T>>(state: FeatureAreaState<T>, snapshot: T[]): FeatureAreaState<T>;
+export declare function revertFeatureRename<T extends FeatureAreaItem<T>>(state: FeatureAreaState<T>, id: Guid): FeatureAreaState<T>;
+export declare function containsFeature<T extends FeatureAreaItem<T>>(features: T[], id: Guid): boolean;
+export declare function collapseFeature<T extends FeatureAreaItem<T>>(features: T[], id: string, collapsed: boolean): T[];
+export declare function renameFeature<T extends FeatureAreaItem<T>>(features: T[], id: string, name: string): T[];
+export declare function orderFeatures<T extends FeatureAreaItem<T>>(features: T[], ids: Guid[]): T[];

package/dist/Features/featureDropEdge.d.ts

@@ -0,0 +1,2 @@
+export type FeatureDropEdge = 'before' | 'after';
+export declare function featureDropEdge(dropIndex: number | undefined, index: number, count: number): FeatureDropEdge | undefined;