@cratis/event-models 0.0.0-stage → 0.105.6

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @cratis/event-models
+
+The Cratis event model board as a React component. It is the same board Cratis Studio draws, both the editor and the read-only viewer.
+
+The package is on `0.x`, so its API can still change between minor versions. Pin a minor version, for example `~0.2.0`.
+
+## Install
+
+```bash
+npm install @cratis/event-models @cratis/scene @cratis/components @cratis/fundamentals primeicons pixi.js react react-dom
+```
+
+Everything except the board itself is a peer dependency, so your application decides the versions.
+
+## Render a board
+
+```tsx
+import { EventModelBoard, readEventModelDocument } from '@cratis/event-models';
+import '@cratis/components/styles';
+import '@cratis/event-models/theme';
+import '@cratis/event-models/styles';
+import '@cratis/scene/styles';
+import 'primeicons/primeicons.css';
+
+const model = readEventModelDocument(json);
+
+export const Board = () => (
+    <div style={{ height: '100vh' }}>
+        <EventModelBoard document={model} readOnly />
+    </div>
+);
+```
+
+- `readEventModelDocument` reads a document shaped like the published JSON Schema (`@cratis/event-models/schema`) into an `EventModel`.
+- The board fills its parent, so give the parent a height.
+- `readOnly` draws the board without any editing gestures. Leave it off and pass `editor` to receive the board's edits as callbacks. The package never persists anything by itself.
+
+## Styling
+
+`@cratis/event-models/styles` holds the board's own CSS. The board paints itself from design tokens: card sizes and colors, and a PrimeReact-style surface and text palette. If your application does not already define them, import `@cratis/event-models/theme` for the values Cratis Studio uses. Every value in it has zero specificity, so anything your application sets on `:root` wins.
+
+The colors follow the page's `color-scheme` (`light-dark()`), and text uses the page's font, so set both on your page.

package/dist/Board/BoardActions.d.ts

@@ -0,0 +1,37 @@
+import type { CardSurface } from '../Cards/CardSurface';
+import type { CellAction } from '../Rows/CellAction';
+import type { PrototypeTemplate } from '../Rows/UserExperience/PrototypeTemplate';
+import type { SpecificationAction, SpecificationCollectionAction, SpecificationGenerationAction } from '../Specifications/SpecificationAction';
+import type { SliceHeaderAction } from '../Slices/SliceHeaderAction';
+import type { FeatureHeaderAction } from '../Features/FeatureHeaderAction';
+import type { FeatureHeaderMenuAction } from '../Features/FeatureHeaderMenuAction';
+import type { FeatureHeaderSuggestion } from '../Features/FeatureHeaderSuggestion';
+import type { ModuleHeaderAction } from '../Modules/ModuleHeaderAction';
+import type { StickyNote } from '../Model';
+export interface BoardActions {
+    stickyNoteCreated?: (note: StickyNote) => void;
+    stickyNoteCreatingChanged?: (busy: boolean) => void;
+    stickyNoteError?: (error: unknown) => void;
+    moduleHeaderLeading?: readonly ModuleHeaderAction[];
+    moduleHeaderMenu?: readonly ModuleHeaderAction[];
+    moduleHeaderAfterMenu?: readonly ModuleHeaderAction[];
+    moduleHeaderAdd?: readonly ModuleHeaderAction[];
+    moduleHeaderSuggestions?: readonly FeatureHeaderSuggestion[];
+    sliceHeader?: readonly SliceHeaderAction[];
+    featureHeader?: readonly FeatureHeaderAction[];
+    featureHeaderLeading?: readonly FeatureHeaderAction[];
+    featureHeaderAfterMenu?: readonly FeatureHeaderAction[];
+    featureHeaderMenu?: readonly FeatureHeaderMenuAction[];
+    featureHeaderAdd?: readonly FeatureHeaderMenuAction[];
+    featureHeaderSuggestions?: readonly FeatureHeaderSuggestion[];
+    eventCard?: CardSurface;
+    commandCard?: CardSurface;
+    readModelCard?: CardSurface;
+    eventsRow?: readonly CellAction[];
+    prototypeTemplates?: readonly PrototypeTemplate[];
+    interactionRow?: readonly CellAction[];
+    specificationRun?: SpecificationAction;
+    specificationStop?: SpecificationAction;
+    specificationsRunAll?: SpecificationCollectionAction;
+    specificationsGenerate?: SpecificationGenerationAction;
+}

package/dist/Board/BoardCanvas.d.ts

@@ -0,0 +1,6 @@
+import { type CanvasProps } from '@cratis/components/Canvas';
+import type { BoardCanvasChrome } from './BoardCanvasChrome';
+export interface BoardCanvasProps extends Omit<CanvasProps, 'controlsLabels' | 'controlsIcons' | 'controlsGlassSurface' | 'captureAttributes' | 'controlsFollowViewportInsets' | 'readOnly'> {
+    chrome?: BoardCanvasChrome;
+}
+export declare const BoardCanvas: ({ chrome, onHelp, helpTitle, ...props }: BoardCanvasProps) => import("react").JSX.Element;

package/dist/Board/BoardCanvasChrome.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import type { CanvasCaptureAttributes, CanvasControlsIcons, CanvasControlsLabels } from '@cratis/components/Canvas';
+export interface BoardCanvasChrome {
+    controlsLabels?: CanvasControlsLabels;
+    controlsIcons?: CanvasControlsIcons;
+    controlsSurface?: ReactNode;
+    captureAttributes?: CanvasCaptureAttributes;
+    controlsFollowViewportInsets?: boolean;
+}

package/dist/Board/BoardCollectionView.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { type CollectionSizeEstimate } from '../Collections';
+import type { BoardCollection, CollectionGridRenderer } from './BoardCollections';
+export interface BoardCollectionViewProps {
+    collection: BoardCollection;
+    estimatedSize: CollectionSizeEstimate;
+    measuredSize?: {
+        width: number;
+        height: number;
+    };
+    onSize: (id: Guid, width: number, height: number) => void;
+    getZoom: () => number;
+    canMove: boolean;
+    onCollectionMoving?: (id: Guid, deltaX: number, deltaY: number) => void;
+    onCollectionMoved?: (id: Guid, position: {
+        x: number;
+        y: number;
+    }) => void;
+    content: (grid: CollectionGridRenderer) => ReactNode;
+}
+export declare const BoardCollectionView: import("react").MemoExoticComponent<({ collection, estimatedSize, measuredSize, onSize, getZoom, canMove, onCollectionMoving, onCollectionMoved, content }: BoardCollectionViewProps) => import("react").JSX.Element>;

package/dist/Board/BoardCollections.d.ts

@@ -0,0 +1,17 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { CollectionGridProps, CollectionItem, CollectionsArea, CollectionsAreaOptions, CollectionSizeEstimate } from '../Collections';
+export interface BoardCollection extends CollectionItem {
+    modules: {
+        id: Guid;
+        name: string;
+    }[];
+}
+export type CollectionGridContent = Omit<CollectionGridProps, 'getZoom' | 'canMove' | 'onCollectionMoving' | 'onCollectionMoved'>;
+export type CollectionGridRenderer = (content: CollectionGridContent) => ReactElement;
+export interface BoardCollections<T extends BoardCollection> extends CollectionsAreaOptions<T> {
+    estimateSize: (collection: T) => CollectionSizeEstimate;
+    countSlices: (collection: T) => number;
+    renderCollection: (collection: T, grid: CollectionGridRenderer) => ReactNode;
+    area?: (area: CollectionsArea<T>, children: ReactNode) => ReactNode;
+}

package/dist/Board/BoardContextValue.d.ts

@@ -0,0 +1,8 @@
+import type { EventModelMessages } from '../Messages';
+import type { EventModelPresentation } from '../Presentation';
+import type { BoardInteraction } from './BoardInteraction';
+export interface BoardContextValue extends BoardInteraction {
+    readOnly: boolean;
+    presentation: EventModelPresentation;
+    messages: EventModelMessages;
+}

package/dist/Board/BoardEditing.d.ts

@@ -0,0 +1,22 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { EventItem, SliceStatus, SliceType } from '../Model';
+import type { TriggerKind } from '../Rows/System/TriggerKind';
+import type { SpecificationEditing } from '../Specifications/SpecificationEditing';
+import type { StickyNoteChanges } from '../StickyNotes/StickyNoteChanges';
+export interface BoardEditing extends SpecificationEditing, StickyNoteChanges {
+    onSliceOpenStateSet?: (sliceId: Guid, isOpen: boolean) => void;
+    onSliceRenamed?: (sliceId: Guid, name: string) => void;
+    onSliceStatusChanged?: (sliceId: Guid, status: SliceStatus) => Promise<boolean | void> | void;
+    onSliceAdded?: (afterSliceId: Guid, sliceType: SliceType) => void;
+    onEventAdded?: (sliceId: Guid) => void;
+    onEventReferenced?: (sliceId: Guid, source: EventItem) => void;
+    onEventRenamed?: (sliceId: Guid, eventId: Guid, name: string) => string | void;
+    onCommandRenamed?: (sliceId: Guid, commandId: Guid, name: string) => void;
+    onReadModelRenamed?: (sliceId: Guid, readModelId: Guid, name: string) => void;
+    onReadModelAdded?: (sliceId: Guid, host: DOMRect) => void;
+    onTriggerKindChosen?: (sliceId: Guid, kind: TriggerKind) => void;
+    onTriggerOpened?: (sliceId: Guid) => void;
+    onPrototypeOpened?: (sliceId: Guid, actorId: string, host: DOMRect) => void;
+    onPrototypeAdded?: (sliceId: Guid, actorId: string, host: DOMRect) => void;
+    onExternalEventAdded?: (sliceId: Guid, source: EventItem) => void;
+}

package/dist/Board/BoardInteraction.d.ts

@@ -0,0 +1,10 @@
+import type { BoardActions } from './BoardActions';
+import type { BoardEditing } from './BoardEditing';
+import type { BoardNavigation } from './BoardNavigation';
+import type { BoardSelection } from './BoardSelection';
+export interface BoardInteraction {
+    editing: BoardEditing;
+    actions: BoardActions;
+    selection: BoardSelection;
+    navigation: BoardNavigation;
+}

package/dist/Board/BoardInteractionContext.d.ts

@@ -0,0 +1,3 @@
+import type { BoardInteraction } from './BoardInteraction';
+export declare const emptyBoardInteraction: BoardInteraction;
+export declare const BoardInteractionContext: import("react").Context<BoardInteraction>;

package/dist/Board/BoardInteractionProvider.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { BoardInteraction } from './BoardInteraction';
+export type BoardInteractionProviderProps = Partial<BoardInteraction> & {
+    children?: React.ReactNode;
+};
+export declare const BoardInteractionProvider: ({ editing, actions, selection, navigation, children }: BoardInteractionProviderProps) => React.JSX.Element;

package/dist/Board/BoardNavigation.d.ts

@@ -0,0 +1,4 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface BoardNavigation {
+    onNavigateToEvent?: (eventId: Guid) => void;
+}

package/dist/Board/BoardProvider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { BoardInteraction } from './BoardInteraction';
+export interface BoardProviderProps extends Partial<BoardInteraction> {
+    readOnly?: boolean;
+    children?: React.ReactNode;
+}
+export declare const BoardProvider: ({ readOnly, editing, actions, selection, navigation, children }: BoardProviderProps) => React.JSX.Element;

package/dist/Board/BoardReadOnlyContext.d.ts

@@ -0,0 +1 @@
+export declare const BoardReadOnlyContext: import("react").Context<boolean>;

package/dist/Board/BoardSelection.d.ts

@@ -0,0 +1,5 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface BoardSelection {
+    selectedArtifactId?: Guid;
+    onArtifactSelected?: (artifactId: Guid) => void;
+}

package/dist/Board/BoardToolbar.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export interface BoardToolbarProps {
+    slotName: string;
+    order?: number;
+    children?: ReactNode;
+}
+export declare const BoardToolbar: ({ slotName, order, children }: BoardToolbarProps) => import("react").JSX.Element | undefined;

package/dist/Board/EventModelBoard.d.ts

@@ -0,0 +1,13 @@
+import { type Ref } from 'react';
+import type { EventModel } from '../Model';
+import type { EventModelBoardCanvas, EventModelBoardEditor } from './EventModelBoardEditor';
+import type { EventModelBoardHandle } from './EventModelBoardHandle';
+export interface EventModelBoardProps {
+    document: EventModel;
+    readOnly?: boolean;
+    editor?: EventModelBoardEditor;
+    canvas?: EventModelBoardCanvas;
+    showMinimap?: boolean;
+    handle?: Ref<EventModelBoardHandle>;
+}
+export declare const EventModelBoard: ({ document, readOnly, editor, canvas, showMinimap, handle }: EventModelBoardProps) => import("react").JSX.Element;

package/dist/Board/EventModelBoardEditor.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { ModuleCollection } from '../Model';
+import type { CollectionGridProps } from '../Collections';
+import type { CollectionsAreaOptions } from '../Collections';
+import type { ModuleCollectionLinksProps } from '../Links';
+import type { BoardCanvasProps } from './BoardCanvas';
+import type { BoardInteraction } from './BoardInteraction';
+export type EventModelBoardCanvas = Omit<BoardCanvasProps, 'children' | 'minimapItems' | 'minimapWorldWidth' | 'minimapWorldHeight' | 'showMinimap'>;
+export interface EventModelBoardInteractions extends Partial<BoardInteraction> {
+    links?: Pick<ModuleCollectionLinksProps, 'onCollectionsLinked' | 'onCollectionsUnlinked' | 'onPersistenceError'>;
+}
+export interface EventModelBoardEditor extends EventModelBoardInteractions {
+    collections?: Pick<CollectionsAreaOptions<ModuleCollection>, 'onAddCollection' | 'onCollectionMoved' | 'onCollectionsChange' | 'onPersistenceError'>;
+    collectionBoundary?: (collection: ModuleCollection, children: ReactNode) => ReactNode;
+    collection?: (collection: ModuleCollection) => Omit<CollectionGridProps, 'collection' | 'getZoom' | 'onCollectionMoving' | 'onCollectionMoved' | 'canMove'>;
+}

package/dist/Board/EventModelBoardHandle.d.ts

@@ -0,0 +1,5 @@
+import type { Position } from '../Model';
+export interface EventModelBoardHandle {
+    addCollection(x: number, y: number): Promise<void>;
+    addStickyNote(center: Position): void;
+}

package/dist/Board/HostedEventModelBoard.d.ts

@@ -0,0 +1,18 @@
+import { type Ref } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { ModuleCollectionLink, StickyNote } from '../Model';
+import type { BoardCollection, BoardCollections } from './BoardCollections';
+import type { EventModelBoardCanvas, EventModelBoardInteractions } from './EventModelBoardEditor';
+import type { EventModelBoardHandle } from './EventModelBoardHandle';
+export interface HostedEventModelBoardProps<T extends BoardCollection> {
+    id: Guid;
+    collections: BoardCollections<T>;
+    links: ModuleCollectionLink[];
+    stickyNotes: readonly StickyNote[];
+    readOnly?: boolean;
+    editor?: EventModelBoardInteractions;
+    canvas?: EventModelBoardCanvas;
+    showMinimap?: boolean;
+    handle?: Ref<EventModelBoardHandle>;
+}
+export declare const HostedEventModelBoard: <T extends BoardCollection>({ id, readOnly, showMinimap, editor, ...props }: HostedEventModelBoardProps<T>) => import("react").JSX.Element;

package/dist/Board/boardMinimap.d.ts

@@ -0,0 +1,20 @@
+import type { Position } from '../Model';
+export interface BoardMinimapItem {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+}
+export interface BoardMinimap {
+    items: BoardMinimapItem[];
+    worldWidth: number;
+    worldHeight: number;
+}
+export declare const boardMinimap: (collections: readonly {
+    position?: Position;
+    size: {
+        width: number;
+        height: number;
+    };
+}[]) => BoardMinimap;

package/dist/Board/index.d.ts

@@ -0,0 +1,19 @@
+export * from './BoardContextValue';
+export * from './BoardActions';
+export * from './BoardEditing';
+export * from './BoardInteraction';
+export * from './BoardInteractionProvider';
+export * from './BoardNavigation';
+export * from './BoardSelection';
+export * from './BoardProvider';
+export * from './useBoard';
+export * from './BoardCanvas';
+export * from './EventModelBoard';
+export * from './EventModelBoardEditor';
+export * from './EventModelBoardHandle';
+export * from './BoardCollections';
+export * from './HostedEventModelBoard';
+export * from './boardMinimap';
+export * from './isLargeBoard';
+export * from './BoardCanvasChrome';
+export * from './BoardToolbar';

package/dist/Board/isLargeBoard.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleCollection } from '../Model';
+export declare const LARGE_BOARD_SLICE_COUNT = 40;
+export declare const countCollectionSlices: (collection: ModuleCollection) => number;
+export declare const isLargeBoard: (sliceCount: number) => boolean;

package/dist/Board/useBoard.d.ts

@@ -0,0 +1,2 @@
+import type { BoardContextValue } from './BoardContextValue';
+export declare const useBoard: () => BoardContextValue;

package/dist/Cards/ArtifactCard.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { JsonSchema } from '@cratis/components/SchemaEditor';
+import type { Guid } from '@cratis/fundamentals';
+import { ArtifactCardKind } from './ArtifactCardKind';
+import { type CardProps } from './Card';
+import type { CardAction } from './CardAction';
+export interface ArtifactCardProps extends Omit<CardProps, 'backgroundColor' | 'textColor' | 'extraContent'> {
+    kind: ArtifactCardKind;
+    artifactId?: Guid;
+    summary?: string;
+    tags?: readonly string[];
+    schema?: string | JsonSchema;
+    showDetails?: boolean;
+    actions?: readonly CardAction[];
+    onActivate?: (artifactId: Guid, host: DOMRect) => void;
+}
+export declare const ArtifactCard: ({ kind, artifactId, summary, tags, schema, showDetails, actions, onActivate, onSelected, ...cardProps }: ArtifactCardProps) => React.JSX.Element;

package/dist/Cards/ArtifactCardKind.d.ts

@@ -0,0 +1,5 @@
+export declare enum ArtifactCardKind {
+    command = "command",
+    readModel = "readModel",
+    event = "event"
+}

package/dist/Cards/Card.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export interface CardProps {
+    name: string;
+    backgroundColor: string;
+    textColor: string;
+    isSelected?: boolean;
+    disabled?: boolean;
+    onSelected?: () => void;
+    onStartEdit?: () => void;
+    extraContent?: React.ReactNode;
+    children?: React.ReactNode;
+    ariaLabel?: string;
+    ariaPressed?: boolean;
+    'data-event-id'?: string;
+    'data-card-id'?: string;
+    'data-slice-id'?: string;
+}
+export declare const Card: React.FC<CardProps>;

package/dist/Cards/CardAction.d.ts

@@ -0,0 +1,12 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { CardCorner } from './CardCorner';
+export interface CardAction {
+    icon: string;
+    tooltip: string;
+    corner?: CardCorner;
+    when?: (artifactId: Guid) => boolean;
+    active?: boolean;
+    disabled?: boolean;
+    busy?: boolean;
+    onActivate: (artifactId: Guid, host: DOMRect) => void;
+}

package/dist/Cards/CardActionButton.d.ts

@@ -0,0 +1,9 @@
+import type { CardAction } from './CardAction';
+import { CardCorner } from './CardCorner';
+export interface CardActionButtonProps {
+    action: CardAction;
+    corner: CardCorner;
+    slot: number;
+    onActivate: () => void;
+}
+export declare const CardActionButton: ({ action, corner, slot, onActivate }: CardActionButtonProps) => import("react").JSX.Element;

package/dist/Cards/CardCorner.d.ts

@@ -0,0 +1,4 @@
+export declare enum CardCorner {
+    start = "start",
+    end = "end"
+}

package/dist/Cards/CardNameInput.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface CardNameInputProps {
+    value: string;
+    backgroundColor: string;
+    textColor: string;
+    nameError?: string;
+    onChange: (value: string) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+}
+export declare const CardNameInput: React.FC<CardNameInputProps>;

package/dist/Cards/CardSurface.d.ts

@@ -0,0 +1,6 @@
+import type { CardAction } from './CardAction';
+import type { Guid } from '@cratis/fundamentals';
+export interface CardSurface {
+    onActivate?: (artifactId: Guid, host: DOMRect) => void;
+    actions?: readonly CardAction[];
+}

package/dist/Cards/EventTags.d.ts

@@ -0,0 +1,8 @@
+export interface EventTagsProps {
+    /** The tags to render. */
+    tags?: readonly string[];
+}
+/**
+ * Renders the tags of an event type as a row of chips on the event card.
+ */
+export declare const EventTags: ({ tags }: EventTagsProps) => import("react").JSX.Element | null;

package/dist/Cards/autoFitTitle.d.ts

@@ -0,0 +1,29 @@
+/** The default largest font size a card title renders at — matches the existing card face font size. */
+export declare const DEFAULT_MAX_TITLE_FONT_SIZE_PX = 13;
+/** The default smallest single-line font size before a title switches to wrapping across two lines. */
+export declare const DEFAULT_MIN_TITLE_FONT_SIZE_PX = 10;
+/** Measures the rendered pixel width of `text` at `fontSizePx`. Implemented with real font metrics by
+ *  {@link useAutoFitTitle}; injected here so {@link computeAutoFitTitle} stays a pure, spec-able function. */
+export type MeasureTextWidth = (text: string, fontSizePx: number) => number;
+export interface AutoFitTitleOptions {
+    /** The largest font size to try, in pixels. */
+    maxFontSizePx: number;
+    /** The smallest single-line font size to try before falling back to a two-line wrap, in pixels. */
+    minFontSizePx: number;
+    /** The width available to the title, in pixels. */
+    availableWidthPx: number;
+}
+export interface AutoFitTitleResult {
+    /** The font size to render the title at, in pixels. */
+    fontSizePx: number;
+    /** The line(s) to render. A single entry when the title fits on one line; two when it was wrapped. */
+    lines: string[];
+}
+/**
+ * Finds the largest font size (within `options`) at which `text` fits on a single line within
+ * `availableWidthPx`, shrinking from `maxFontSizePx` down to `minFontSizePx`. When even `minFontSizePx`
+ * does not fit on one line, wraps the text across two lines at the nearest PascalCase word boundary
+ * (see {@link splitAtPascalCaseBreak}) and renders those at `minFontSizePx`, rather than shrinking the
+ * font further into unreadable territory.
+ */
+export declare function computeAutoFitTitle(text: string, options: AutoFitTitleOptions, measure: MeasureTextWidth): AutoFitTitleResult;

package/dist/Cards/cardColors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Raw hex values for card colors.
+ *
+ * These MUST match the CSS custom properties defined in .frontend/index.css
+ * (--card-event-bg, --card-command-bg, etc.) so that both JS-driven inline
+ * styles and CSS class rules resolve to the same palette.
+ */
+/** Background and text colors for event-modeling card types. */
+export interface CardColors {
+    /** Card face background color. */
+    background: string;
+    /** Card face text color. */
+    text: string;
+}
+/** Event (domain event) card colors — warm orange. */
+export declare const eventCardColors: CardColors;
+/** Command card colors — sky blue. */
+export declare const commandCardColors: CardColors;
+/** Read model card colors — lime green. */
+export declare const readModelCardColors: CardColors;
+/** External event (event from another module the Translator translates from) card colors — yellow, the event-modeling convention for external events. */
+export declare const externalEventCardColors: CardColors;
+/**
+ * Concept card colors — violet, the color the event-model board already gives to the structural
+ * (feature) level rather than to any of the event/command/read-model artifacts. A concept is neither of
+ * those, so it gets its own place in the same palette instead of borrowing one of theirs.
+ */
+export declare const conceptCardColors: CardColors;
+/** Error card colors — red. */
+export declare const errorCardColors: CardColors;

package/dist/Cards/index.d.ts

@@ -0,0 +1,12 @@
+export * from './Card';
+export * from './cardColors';
+export * from './pascalCaseBreak';
+export * from './autoFitTitle';
+export * from './useAutoFitTitle';
+export * from './ArtifactCard';
+export * from './ArtifactCardKind';
+export * from './CardAction';
+export * from './CardCorner';
+export * from './EventTags';
+export * from './CardSurface';
+export * from './CardNameInput';

package/dist/Cards/pascalCaseBreak.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Finds the index of the best place to break a PascalCase name (e.g. an event or command type name like
+ * `CustomerAddressUpdated`) into two lines, so a wrapped card title breaks at a word boundary rather than
+ * mid-word. Candidates are ranked in two tiers, closest-to-the-middle first within each tier:
+ *
+ *  1. A "word start" — an uppercase letter directly preceded by a lowercase letter (`...ss|Up...` in
+ *     `AddressUpdated`). This is the overwhelmingly common case for Cratis event/command names.
+ *  2. Any other uppercase letter (index > 0) — a fallback for names built from acronym runs
+ *     (`HTTPServer`) where tier 1 finds nothing, since there is no lowercase-to-uppercase transition.
+ *
+ * Returns `null` when the text has no uppercase letter to break before (e.g. a single lowercase word, or
+ * text too short to usefully split) — callers fall back to a plain midpoint split in that case.
+ */
+export declare function nearestPascalCaseBreakIndex(text: string): number | null;
+/**
+ * Splits a PascalCase name into two lines at the {@link nearestPascalCaseBreakIndex}. Falls back to an
+ * even midpoint split when no uppercase boundary exists, so every name can still be wrapped rather than
+ * truncated with an ellipsis.
+ */
+export declare function splitAtPascalCaseBreak(text: string): [string, string];

package/dist/Cards/useAutoFitTitle.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+import { AutoFitTitleResult } from './autoFitTitle';
+export interface UseAutoFitTitleOptions {
+    /** The CSS font-family the title renders with — must match the element's actual styling for accurate measurement. */
+    fontFamily: string;
+    /** The CSS font-weight the title renders with. */
+    fontWeight: string | number;
+    /** The largest font size to try, in pixels. Defaults to {@link DEFAULT_MAX_TITLE_FONT_SIZE_PX}. */
+    maxFontSizePx?: number;
+    /** The smallest single-line font size before wrapping, in pixels. Defaults to {@link DEFAULT_MIN_TITLE_FONT_SIZE_PX}. */
+    minFontSizePx?: number;
+}
+/**
+ * Measures `text` against the width of the element attached to the returned ref and shrinks/wraps it to
+ * fit, via {@link computeAutoFitTitle}. Re-measures whenever the text or font options change.
+ *
+ * The element the ref attaches to must already be laid out at its final width when this runs (a block
+ * element that doesn't grow with its own text content, e.g. `white-space: nowrap; overflow: hidden`) —
+ * its `clientWidth` at effect time is taken as the space available to the title.
+ */
+export declare function useAutoFitTitle<T extends HTMLElement>(text: string, options: UseAutoFitTitleOptions): [RefObject<T | null>, AutoFitTitleResult];

package/dist/Collections/CollectionGrid.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import { type RowLabelsColumnProps } from '../RowLabels';
+import type { Feature, Module, ModuleCollection } from '../Model';
+import type { CollectionGridSlots } from './CollectionGridSlots';
+import type { CollectionGridEditor } from './CollectionGridEditor';
+export interface CollectionGridProps extends CollectionGridEditor {
+    collection: ModuleCollection;
+    getZoom?: () => number;
+    slots?: CollectionGridSlots;
+    onDeselect?: () => void;
+    onCollectionMoving?: (id: Guid, deltaX: number, deltaY: number) => void;
+    onCollectionMoved?: (id: Guid, position: {
+        x: number;
+        y: number;
+    }) => void;
+    canMove?: boolean;
+    onAddModule?: () => Promise<Module | undefined>;
+    onModulesReordered?: (ids: Guid[]) => Promise<boolean>;
+    onCollapseChanged?: (id: Guid, collapsed: boolean) => Promise<boolean>;
+    onRenameModule?: (id: Guid, name: string) => Promise<boolean>;
+    onModulesChanged?: (modules: Module[]) => void;
+    onFeaturesChanged?: (moduleId: Guid, features: Feature[]) => void;
+    onPersistenceError?: (error: unknown) => void;
+    rowLabels?: (props: RowLabelsColumnProps) => ReactNode;
+    onActorsReordered?: RowLabelsColumnProps['onActorsReordered'];
+}
+export declare const CollectionGrid: ({ collection, getZoom, slots, onDeselect, onCollectionMoving, onCollectionMoved, canMove, onAddModule, onModulesReordered, onCollapseChanged, onRenameModule, onModulesChanged, onFeaturesChanged, onPersistenceError, rowLabels, onActorsReordered, onAddFeature, onRenameFeature, onFeatureCollapseChanged, onFeaturesReordered, onAddSlice, onReorderSlices, onMoveSlice, validateSliceDrop, onSliceCollapseChanged, onSliceRenamed, onSliceDuplicated }: CollectionGridProps) => import("react").JSX.Element;

package/dist/Collections/CollectionGridEditor.d.ts

@@ -0,0 +1,16 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { Feature, Slice } from '../Model';
+import type { ValidateSliceDrop } from '../SliceDragging';
+export interface CollectionGridEditor {
+    onAddFeature?: (moduleId: Guid, name?: string, parentId?: Guid) => Promise<Feature | undefined>;
+    onRenameFeature?: (featureId: Guid, name: string) => Promise<void>;
+    onFeatureCollapseChanged?: (featureId: Guid, collapsed: boolean) => void;
+    onFeaturesReordered?: (moduleId: Guid, features: Feature[]) => void;
+    onAddSlice?: (featureId: Guid, slice: Slice, afterSliceId?: Guid) => Promise<Guid | undefined>;
+    onReorderSlices?: (featureId: Guid, sliceIds: Guid[]) => Promise<boolean>;
+    onMoveSlice?: (slice: Slice, sourceFeatureId: Guid, targetFeatureId: Guid, targetIndex: number) => Promise<boolean>;
+    validateSliceDrop?: ValidateSliceDrop;
+    onSliceCollapseChanged?: (featureId: Guid, sliceId: Guid, collapsed: boolean) => void;
+    onSliceRenamed?: (featureId: Guid, sliceId: Guid, name: string) => void;
+    onSliceDuplicated?: (featureId: Guid, sourceSliceId: Guid, newSliceId: Guid) => void;
+}