@cratis/event-models 0.0.0-stage → 0.105.6

package/dist/Slices/sliceAreaState.d.ts

@@ -0,0 +1,43 @@
+import type { Guid } from '@cratis/fundamentals';
+export interface SliceAreaItem {
+    id: Guid;
+    name: string;
+    collapsed: boolean;
+}
+interface PendingAddition<T> {
+    slice: T;
+    afterSliceId?: Guid;
+    confirmed: boolean;
+}
+interface PendingMove<T> {
+    slice: T;
+    index: number;
+    confirmed: boolean;
+}
+export interface SliceAreaState<T extends SliceAreaItem> {
+    slices: T[];
+    snapshot: T[];
+    additions: PendingAddition<T>[];
+    outgoing: PendingMove<T>[];
+    incoming: PendingMove<T>[];
+    order?: {
+        ids: Guid[];
+        confirmed: boolean;
+    };
+}
+export declare const createSliceAreaState: <T extends SliceAreaItem>(slices: T[]) => SliceAreaState<T>;
+export declare const insertSlice: <T extends SliceAreaItem>(slices: T[], slice: T, afterSliceId?: Guid) => T[];
+export declare const settleAddedSlice: <T extends SliceAreaItem>(slices: T[], temporaryId: Guid, persistedId?: Guid) => T[];
+export declare const addPendingSlice: <T extends SliceAreaItem>(state: SliceAreaState<T>, slice: T, afterSliceId?: Guid) => SliceAreaState<T>;
+export declare const addProjectedSlice: <T extends SliceAreaItem>(state: SliceAreaState<T>, slice: T, afterSliceId?: Guid) => SliceAreaState<T>;
+export declare const completeAddedSlice: <T extends SliceAreaItem>(state: SliceAreaState<T>, temporaryId: Guid, persistedId?: Guid) => SliceAreaState<T>;
+export declare const moveSliceInArea: <T extends SliceAreaItem>(slices: T[], fromIndex: number, toIndex: number) => T[];
+export declare const reorderPendingSlices: <T extends SliceAreaItem>(state: SliceAreaState<T>, fromIndex: number, toIndex: number) => SliceAreaState<T>;
+export declare const completeReorder: <T extends SliceAreaItem>(state: SliceAreaState<T>, succeeded: boolean) => SliceAreaState<T>;
+export declare const movePendingSliceOut: <T extends SliceAreaItem>(state: SliceAreaState<T>, id: Guid) => SliceAreaState<T>;
+export declare const completeMoveOut: <T extends SliceAreaItem>(state: SliceAreaState<T>, id: Guid, succeeded: boolean) => SliceAreaState<T>;
+export declare const movePendingSliceIn: <T extends SliceAreaItem>(state: SliceAreaState<T>, slice: T, index: number) => SliceAreaState<T>;
+export declare const completeMoveIn: <T extends SliceAreaItem>(state: SliceAreaState<T>, id: Guid, succeeded: boolean) => SliceAreaState<T>;
+export declare const reconcileSliceSnapshot: <T extends SliceAreaItem>(state: SliceAreaState<T>, snapshot: T[]) => SliceAreaState<T>;
+export declare const duplicateSliceName: (names: string[], original: string) => string;
+export {};

package/dist/Slices/useSlice.d.ts

@@ -0,0 +1,3 @@
+import type { SliceContextValue } from './SliceContextValue';
+export declare const useSlice: () => SliceContextValue;
+export declare const useSliceReadOnly: () => boolean;

package/dist/Specifications/GivenSection.d.ts

@@ -0,0 +1,12 @@
+import { Guid } from '@cratis/fundamentals';
+import type { EventItem, ReadModelItem, SliceSpecification } from '../Model';
+import { SliceType } from '../Model';
+export interface GivenSectionProps {
+    sliceId: Guid;
+    sliceType: SliceType;
+    specification: SliceSpecification;
+    events: readonly EventItem[];
+    readModel?: ReadModelItem;
+    renamedReadModelName?: string;
+}
+export declare const GivenSection: ({ sliceId, sliceType, specification, events, readModel, renamedReadModelName }: GivenSectionProps) => import("react").JSX.Element;

package/dist/Specifications/SpecificationAction.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceSpecification } from '../Model';
+export interface SpecificationAction {
+    icon: ReactNode;
+    tooltip: string;
+    when?: (specification: SliceSpecification) => boolean;
+    onActivate: (specificationId: Guid, host: DOMRect) => void | Promise<void>;
+}
+export interface SpecificationCollectionAction {
+    icon: ReactNode;
+    tooltip: string;
+    disabled?: boolean;
+    when?: (sliceId: Guid) => boolean;
+    onActivate: (sliceId: Guid, host: DOMRect) => void | Promise<void>;
+}
+export interface SpecificationGenerationAction extends Omit<SpecificationCollectionAction, 'onActivate'> {
+    onActivate: (sliceId: Guid, host: DOMRect) => Promise<boolean>;
+}

package/dist/Specifications/SpecificationAddPicker.d.ts

@@ -0,0 +1,11 @@
+export interface SpecificationAddExtra {
+    label: string;
+    onChosen: () => void;
+}
+export interface SpecificationAddPickerProps<TOption> {
+    options: readonly TOption[];
+    nameOf: (option: TOption) => string;
+    onChosen: (option: TOption) => void;
+    errors?: readonly SpecificationAddExtra[];
+}
+export declare const SpecificationAddPicker: <TOption>({ options, nameOf, onChosen, errors }: SpecificationAddPickerProps<TOption>) => import("react").JSX.Element;

package/dist/Specifications/SpecificationCollection.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import { Guid } from '@cratis/fundamentals';
+import type { SliceSpecification } from '../Model';
+import { SpecificationRunState } from './SpecificationRunState';
+export interface SpecificationCollectionProps {
+    sliceId: Guid;
+    width: number;
+    collapsed: boolean;
+    specifications: SliceSpecification[];
+    runInfoFor: (specification: SliceSpecification) => {
+        state: SpecificationRunState;
+        message: string;
+    };
+    renderRows: (specification: SliceSpecification) => ReactNode;
+}
+export declare const SpecificationCollection: ({ sliceId, width, collapsed, specifications: incoming, runInfoFor, renderRows }: SpecificationCollectionProps) => import("react").JSX.Element | null;

package/dist/Specifications/SpecificationEditing.d.ts

@@ -0,0 +1,20 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { SliceSpecification, SpecificationErrorRuleReference } from '../Model';
+import type { SpecificationItemToOpen } from './SpecificationItemToOpen';
+export interface SpecificationEditing {
+    onSpecificationAdded?: (sliceId: Guid, specification: SliceSpecification) => Promise<boolean>;
+    onSpecificationRemoved?: (sliceId: Guid, specificationId: Guid) => void;
+    onSpecificationRenamed?: (sliceId: Guid, specificationId: Guid, name: string) => void;
+    onSpecificationOpenStateSet?: (sliceId: Guid, specificationId: Guid, isOpen: boolean) => void;
+    onGivenEventAdded?: (sliceId: Guid, specificationId: Guid, itemId: Guid, eventId: Guid, name: string) => void;
+    onGivenEventValuesSet?: (sliceId: Guid, specificationId: Guid, itemId: Guid, values: Record<string, unknown>) => void;
+    onGivenReadModelSet?: (sliceId: Guid, specificationId: Guid, readModelId: Guid, name: string) => void;
+    onWhenCommandSet?: (sliceId: Guid, specificationId: Guid, itemId: Guid, commandId: Guid, name: string) => void;
+    onWhenCommandValuesSet?: (sliceId: Guid, specificationId: Guid, values: Record<string, unknown>) => void;
+    onThenEventAdded?: (sliceId: Guid, specificationId: Guid, itemId: Guid, eventId: Guid, name: string) => void;
+    onThenEventValuesSet?: (sliceId: Guid, specificationId: Guid, itemId: Guid, values: Record<string, unknown>) => void;
+    onThenErrorAdded?: (sliceId: Guid, specificationId: Guid, itemId: Guid, name: string) => void;
+    onThenRuleErrorAdded?: (sliceId: Guid, specificationId: Guid, itemId: Guid, reference: SpecificationErrorRuleReference) => void;
+    onThenErrorRenamed?: (sliceId: Guid, specificationId: Guid, itemId: Guid, name: string) => void;
+    onSpecificationItemOpened?: (item: SpecificationItemToOpen) => void;
+}

package/dist/Specifications/SpecificationErrorCard.d.ts

@@ -0,0 +1,5 @@
+export interface SpecificationErrorCardProps {
+    name: string;
+    onRenamed?: (name: string) => void;
+}
+export declare const SpecificationErrorCard: ({ name, onRenamed }: SpecificationErrorCardProps) => import("react").JSX.Element;

package/dist/Specifications/SpecificationHeader.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+import { SpecificationRunState } from './SpecificationRunState';
+export interface SpecificationHeaderProps {
+    name: string;
+    collapsed: boolean;
+    onToggleCollapse?: () => void;
+    runState: SpecificationRunState;
+    runMessage?: string;
+    onRenamed?: (name: string) => void;
+    onDeleted?: () => void;
+    runControl?: ReactNode;
+    gutter?: ReactNode;
+}
+export declare const SpecificationHeader: ({ name, collapsed, onToggleCollapse, runState, runMessage, onRenamed, onDeleted, runControl, gutter, }: SpecificationHeaderProps) => import("react").JSX.Element;

package/dist/Specifications/SpecificationItemCard.d.ts

@@ -0,0 +1,7 @@
+import { type CardColors } from '../Cards';
+export interface SpecificationItemCardProps {
+    name: string;
+    colors: CardColors;
+    onOpen?: (host: DOMRect) => void;
+}
+export declare const SpecificationItemCard: ({ name, colors, onOpen }: SpecificationItemCardProps) => import("react").JSX.Element;

package/dist/Specifications/SpecificationItemKind.d.ts

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

package/dist/Specifications/SpecificationItemToOpen.d.ts

@@ -0,0 +1,14 @@
+import type { Guid } from '@cratis/fundamentals';
+import type { JsonSchema } from '@cratis/components/types';
+import type { SpecificationItemKind } from './SpecificationItemKind';
+export interface SpecificationItemToOpen {
+    sliceId: Guid;
+    specificationId: Guid;
+    itemId: Guid;
+    kind: SpecificationItemKind;
+    name: string;
+    schema?: JsonSchema;
+    values: Readonly<Record<string, unknown>>;
+    host: DOMRect;
+    onValuesSet: (values: Record<string, unknown>) => void;
+}

package/dist/Specifications/SpecificationRow.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export interface SpecificationRowProps {
+    headline: string;
+    actions?: ReactNode;
+    isLast?: boolean;
+    children?: ReactNode;
+}
+export declare const SpecificationRow: ({ headline, actions, isLast, children }: SpecificationRowProps) => import("react").JSX.Element;

package/dist/Specifications/SpecificationRunButton.d.ts

@@ -0,0 +1,7 @@
+import type { SliceSpecification } from '../Model';
+import { SpecificationRunState } from './SpecificationRunState';
+export interface SpecificationRunButtonProps {
+    state: SpecificationRunState;
+    specification: SliceSpecification;
+}
+export declare const SpecificationRunButton: ({ state, specification }: SpecificationRunButtonProps) => import("react").JSX.Element | null;

package/dist/Specifications/SpecificationRunState.d.ts

@@ -0,0 +1,23 @@
+import { SpecificationRunOutcome } from '../Model';
+/**
+ * Represents the run state of a specification as shown in the UI.
+ */
+export declare enum SpecificationRunState {
+    /** No run has happened and none is in progress. */
+    Idle = "idle",
+    /** A run is currently in progress. */
+    Running = "running",
+    /** The latest run passed. */
+    Passed = "passed",
+    /** The latest run failed. */
+    Failed = "failed",
+    /** The latest run could not be conclusively verified. */
+    Inconclusive = "inconclusive"
+}
+/**
+ * Derives the UI run state from the latest persisted outcome and whether a run is currently in progress.
+ * @param outcome The latest persisted outcome, or undefined when no run has completed.
+ * @param isRunning Whether a run is currently in progress.
+ * @returns The {@link SpecificationRunState}.
+ */
+export declare function specificationRunState(outcome: SpecificationRunOutcome | undefined, isRunning: boolean): SpecificationRunState;

package/dist/Specifications/SpecificationSection.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export interface SpecificationSectionProps {
+    headline?: string;
+    minHeight: number;
+    actions?: ReactNode;
+    children?: ReactNode;
+}
+export declare const SpecificationSection: ({ headline, minHeight, actions, children }: SpecificationSectionProps) => import("react").JSX.Element;

package/dist/Specifications/SpecificationStatus.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { SpecificationRunState } from './SpecificationRunState';
+export interface SpecificationStatusProps {
+    /** The current run state of the specification. */
+    state: SpecificationRunState;
+    /** The last run's failure message, surfaced in the tooltip when the run failed. */
+    message?: string;
+}
+/**
+ * A circular status badge that reflects the outcome of a specification's last run — mirroring the slice status
+ * badge — showing whether it has not been run, succeeded, or failed (with the failure reason in its tooltip).
+ * When failed with a message, renders as a button to make the error more discoverable.
+ */
+export declare const SpecificationStatus: React.FC<SpecificationStatusProps>;

package/dist/Specifications/ThenSection.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+import { Guid } from '@cratis/fundamentals';
+import type { CommandItem, EventItem, ReadModelItem, SliceSpecification } from '../Model';
+import { SliceType } from '../Model';
+export interface ThenSectionProps {
+    sliceId: Guid;
+    sliceType: SliceType;
+    specification: SliceSpecification;
+    events: readonly EventItem[];
+    command?: CommandItem;
+    readModel?: ReadModelItem;
+    renamedEventNames?: Readonly<Record<string, string>>;
+    extra?: ReactNode;
+}
+export declare const ThenSection: ({ sliceId, sliceType, specification, events, command, readModel, renamedEventNames, extra }: ThenSectionProps) => import("react").JSX.Element;

package/dist/Specifications/WhenSection.d.ts

@@ -0,0 +1,12 @@
+import { Guid } from '@cratis/fundamentals';
+import type { CommandItem, EventItem, SliceSpecification } from '../Model';
+import { SliceType } from '../Model';
+export interface WhenSectionProps {
+    sliceId: Guid;
+    sliceType: SliceType;
+    specification: SliceSpecification;
+    command?: CommandItem;
+    renamedCommandName?: string;
+    events?: readonly EventItem[];
+}
+export declare const WhenSection: ({ sliceId, sliceType, specification, command, renamedCommandName, events }: WhenSectionProps) => import("react").JSX.Element;

package/dist/Specifications/index.d.ts

@@ -0,0 +1,10 @@
+export * from './SpecificationRunState';
+export * from './SpecificationRunButton';
+export * from './SpecificationStatus';
+export * from './SpecificationHeader';
+export * from './SpecificationCollection';
+export * from './specificationCollectionState';
+export * from './SpecificationSection';
+export * from './GivenSection';
+export * from './WhenSection';
+export * from './ThenSection';

package/dist/Specifications/itemValues.d.ts

@@ -0,0 +1,7 @@
+export type ItemValues = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+export declare const itemValuesOf: (items: readonly {
+    id: {
+        toString(): string;
+    };
+    values: Record<string, unknown>;
+}[]) => ItemValues;

package/dist/Specifications/ruleErrors.d.ts

@@ -0,0 +1,8 @@
+import { type CommandItem, type EventItem, type SpecificationErrorRuleReference } from '../Model';
+export interface RuleErrorOption {
+    reference: SpecificationErrorRuleReference;
+    label: string;
+}
+export declare const humanizeRuleType: (ruleType: string) => string;
+export declare const ruleErrorOptions: (command: CommandItem | undefined, events: readonly EventItem[]) => RuleErrorOption[];
+export declare const ruleErrorLabel: (reference: SpecificationErrorRuleReference, events: readonly EventItem[]) => string | undefined;

package/dist/Specifications/specificationCollectionState.d.ts

@@ -0,0 +1,7 @@
+import type { SliceSpecification } from '../Model';
+import type { SpecificationEditing } from './SpecificationEditing';
+export declare const GENERATED_SPECIFICATIONS_ABSORB_WINDOW_MS = 15000;
+export declare const specificationContentSize: (specification: SliceSpecification) => number;
+export declare const followsIncomingSpecifications: (readOnly: boolean, editing: SpecificationEditing) => boolean;
+export declare const reconcileSpecifications: (current: SliceSpecification[], incoming: SliceSpecification[], followsIncoming: boolean, withinGenerationWindow: boolean, removedIds: ReadonlySet<string>) => SliceSpecification[];
+export declare const absorbSpecifications: (current: SliceSpecification[], incoming: SliceSpecification[], removedIds?: ReadonlySet<string>) => SliceSpecification[];

package/dist/Specifications/specificationEvents.d.ts

@@ -0,0 +1,3 @@
+import type { EventItem } from '../Model';
+export declare const producedEventsUniqueById: (events: readonly EventItem[]) => EventItem[];
+export declare const offersReadModelInGiven: (hasSliceReadModel: boolean, hasGivenReadModel: boolean) => boolean;

package/dist/Statuses/SliceStatusIcon.d.ts

@@ -0,0 +1,5 @@
+import { SliceStatus } from '../Model';
+export interface SliceStatusIconProps {
+    status: SliceStatus;
+}
+export declare const SliceStatusIcon: ({ status }: SliceStatusIconProps) => import("react").JSX.Element;

package/dist/Statuses/SliceStatusPicker.d.ts

@@ -0,0 +1,8 @@
+import { SliceStatus } from '../Model';
+export interface SliceStatusPickerProps {
+    status: SliceStatus;
+    onStatusChanged?: (status: SliceStatus) => Promise<boolean | void> | void;
+    selectable?: readonly SliceStatus[];
+    unselectableReason?: string;
+}
+export declare const SliceStatusPicker: ({ status, onStatusChanged, selectable, unselectableReason }: SliceStatusPickerProps) => import("react").JSX.Element;

package/dist/Statuses/changeSliceStatus.d.ts

@@ -0,0 +1,2 @@
+import type { SliceStatus } from '../Model';
+export declare const changeSliceStatus: (previous: SliceStatus, picked: SliceStatus, report: (status: SliceStatus) => Promise<boolean | void> | void, show: (status: SliceStatus) => void) => Promise<void>;

package/dist/Statuses/index.d.ts

@@ -0,0 +1,4 @@
+export * from './SliceStatusIcon';
+export * from './SliceStatusPicker';
+export * from './sliceStatuses';
+export * from './changeSliceStatus';

package/dist/Statuses/sliceStatuses.d.ts

@@ -0,0 +1,6 @@
+import { SliceStatus } from '../Model';
+import type { EventModelMessages } from '../Messages';
+export declare const sliceStatusWorkflowOrder: readonly SliceStatus[];
+export declare const sliceStatusColor: (status: SliceStatus) => string;
+export declare const sliceStatusLabel: (status: SliceStatus, messages: EventModelMessages) => string;
+export declare const sliceStatusName: (status: SliceStatus) => string;

package/dist/StickyNotes/StickyNoteBounds.d.ts

@@ -0,0 +1,6 @@
+import type { Position } from '../Model';
+export interface StickyNoteBounds {
+    position: Position;
+    width: number;
+    height: number;
+}

package/dist/StickyNotes/StickyNoteChanges.d.ts

@@ -0,0 +1,9 @@
+import type { Position, StickyNote } from '../Model';
+import type { StickyNoteBounds } from './StickyNoteBounds';
+export interface StickyNoteChanges {
+    onStickyNoteAdded?: (note: StickyNote) => Promise<boolean | void> | boolean | void;
+    onStickyNoteMoved?: (id: string, position: Position) => Promise<boolean | void> | boolean | void;
+    onStickyNoteResized?: (id: string, bounds: StickyNoteBounds) => Promise<boolean | void> | boolean | void;
+    onStickyNoteTextChanged?: (id: string, text: string) => Promise<boolean | void> | boolean | void;
+    onStickyNoteRemoved?: (id: string) => Promise<boolean | void> | boolean | void;
+}

package/dist/StickyNotes/StickyNoteHandle.d.ts

@@ -0,0 +1,4 @@
+import type { Position } from '../Model';
+export interface StickyNoteHandle {
+    add(center: Position): void;
+}

package/dist/StickyNotes/StickyNoteState.d.ts

@@ -0,0 +1,16 @@
+import type { StickyNote } from '../Model';
+export declare class StickyNoteState {
+    private readonly now;
+    private remote;
+    private readonly pending;
+    constructor(notes: readonly StickyNote[], now?: () => number);
+    get notes(): StickyNote[];
+    get(id: string): StickyNote | undefined;
+    change(id: string, note: StickyNote | null): void;
+    begin(id: string, note: StickyNote | null): void;
+    settle(id: string, note: StickyNote | null): void;
+    reconcile(notes: readonly StickyNote[]): void;
+    expire(): void;
+    get nextExpiration(): number | undefined;
+    rollback(id: string, change: StickyNote | null): void;
+}

package/dist/StickyNotes/StickyNotes.d.ts

@@ -0,0 +1,6 @@
+import type { StickyNote } from '../Model';
+import type { StickyNoteHandle } from './StickyNoteHandle';
+export interface StickyNotesProps {
+    notes: readonly StickyNote[];
+}
+export declare const StickyNotes: import("react").ForwardRefExoticComponent<StickyNotesProps & import("react").RefAttributes<StickyNoteHandle>>;

package/dist/StickyNotes/index.d.ts

@@ -0,0 +1,6 @@
+export * from './isEditableTarget';
+export * from './StickyNoteBounds';
+export * from './StickyNoteChanges';
+export * from './StickyNoteHandle';
+export * from './StickyNoteState';
+export * from './StickyNotes';

package/dist/StickyNotes/isEditableTarget.d.ts

@@ -0,0 +1 @@
+export declare const isEditableTarget: (target: EventTarget | null) => boolean;

package/dist/Tooltips/AnchoredOverlay.d.ts

@@ -0,0 +1,27 @@
+import React, { ReactNode, RefObject } from 'react';
+/** The side of the anchor the overlay prefers to open on. */
+export type AnchoredOverlaySide = 'above' | 'below' | 'left' | 'right';
+/** Horizontal alignment relative to the anchor (for above/below overlays). */
+export type AnchoredOverlayAlign = 'left' | 'right' | 'center';
+export interface AnchoredOverlayProps {
+    /** The element the overlay anchors to. */
+    anchorRef: RefObject<HTMLElement | null>;
+    /** Whether the overlay is shown. */
+    open: boolean;
+    /** The preferred side; above/below flip when the viewport leaves no room. */
+    side?: AnchoredOverlaySide;
+    /** Horizontal alignment for above/below overlays. */
+    align?: AnchoredOverlayAlign;
+    /** Gap between the anchor and the overlay in pixels. */
+    gap?: number;
+    /** The overlay content. */
+    children: ReactNode;
+}
+/**
+ * Renders its children into a fixed-position portal on <body>, anchored to an element on the board.
+ * Board overlays (menus, pickers, tooltips) must float above everything: the slice columns use
+ * content-visibility paint containment for virtualization, which clips any absolutely-positioned
+ * descendant to the column box — portaling is what lets an overlay escape (the same approach the
+ * Cratis Dropdown takes with appendTo=document.body).
+ */
+export declare const AnchoredOverlay: React.FC<AnchoredOverlayProps>;

package/dist/Tooltips/GridTooltip.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+export type GridTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+export interface GridTooltipProps {
+    content: React.ReactNode;
+    position?: GridTooltipPosition;
+    children: React.ReactNode;
+}
+/**
+ * A small hover tooltip for canvas cards and controls. The bubble portals to <body> through
+ * AnchoredOverlay so it floats above the whole canvas — an inline absolutely-positioned bubble would be
+ * clipped by paint containment (content-visibility) near a scroll/zoom boundary.
+ *
+ * Pressing the anchor dismisses the bubble and keeps it dismissed until the pointer leaves. Cards that
+ * open an editor on click render it *over* the card without the pointer moving — so the browser never
+ * re-hit-tests and the anchor would otherwise stay "hovered", leaving the property list floating on top
+ * of the editor the user is now typing in.
+ *
+ * Hover is tracked for mouse pointers only: a touch tap synthesizes an enter with no matching leave,
+ * which would strand the bubble on screen on a tablet.
+ */
+export declare const GridTooltip: React.FC<GridTooltipProps>;

package/dist/Tooltips/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AnchoredOverlay';
+export * from './GridTooltip';

package/dist/Viewport/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useInViewport';
+export * from './viewportFlushScheduler';

package/dist/Viewport/useInViewport.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+import { VerdictWeight } from './viewportFlushScheduler';
+export declare function useInViewport(ref: RefObject<Element | null>, rootMargin?: string, weight?: VerdictWeight): boolean;

package/dist/Viewport/viewportFlushScheduler.d.ts

@@ -0,0 +1,7 @@
+type ApplyVerdict = (inView: boolean) => void;
+export type VerdictWeight = 'light' | 'heavy';
+export declare const viewportFlushScheduler: {
+    request(apply: ApplyVerdict, verdict: boolean, distance?: number, weight?: VerdictWeight): void;
+    cancel(apply: ApplyVerdict): void;
+};
+export {};