Kanban

Module Extensions

`KanbanContextMenuConfig`

1
interface KanbanContextMenuConfig {
2
  /** Compose application-provided row context-menu items after Kanban actions. */
3
    readonly includeHostItems?: boolean;
4
  /** Hide built-ins globally or per invoked card/batch while preserving the rest. */
5
    readonly hidden?: Partial<Record<KanbanContextMenuItemId, KanbanContextMenuItemVisibility<T>>>
6
}

`ResolveKanbanCardRuleOptions`

1
interface ResolveKanbanCardRuleOptions {
2
  readonly config: KanbanConfig<T> | ResolvedKanbanConfig<T>;
3
  readonly projectedCard: KanbanProjectedCard<T>;
4
  readonly column: KanbanColumnDefinition<T>;
5
  readonly swimlane: KanbanSwimlaneDefinition;
6
  readonly selected?: boolean;
7
  readonly dragging?: boolean;
8
  /** Internal validation can evaluate visual card rules separately from global callbacks. */
9
    readonly includeGlobalPermissions?: boolean
10
}

`HTMLRevoGridElementEventMap` (Extended from `global`)

1
interface HTMLRevoGridElementEventMap {
2
  [BEFORE_KANBAN_CARD_MOVE_EVENT]: KanbanBeforeCardMoveDetail;
3
  [KANBAN_CARD_MOVE_EVENT]: KanbanCardMoveDetail;
4
  [KANBAN_SELECTION_CHANGE_EVENT]: KanbanSelectionChangeDetail;
5
  [KANBAN_COLUMN_ORDER_CHANGE_EVENT]: KanbanColumnOrderChangeDetail;
6
  [KANBAN_DROP_STATE_CHANGE_EVENT]: KanbanDropStateChangeDetail;
7
  [KANBAN_DIAGNOSTICS_EVENT]: KanbanDiagnosticsDetail;
8
  [KANBAN_CARD_CREATE_REQUEST_EVENT]: KanbanCardRequestDetail;
9
  [KANBAN_CARD_OPEN_REQUEST_EVENT]: KanbanCardRequestDetail;
10
  [KANBAN_CARD_EDIT_REQUEST_EVENT]: KanbanCardRequestDetail;
11
  [KANBAN_CARD_DELETE_REQUEST_EVENT]: KanbanCardRequestDetail;
12
  [BEFORE_KANBAN_CARD_CREATE_EVENT]: KanbanCardCreateDetail;
13
  [KANBAN_CARD_CREATE_EVENT]: KanbanCardCreateDetail;
14
  [BEFORE_KANBAN_CARD_UPDATE_EVENT]: KanbanCardUpdateDetail;
15
  [KANBAN_CARD_UPDATE_EVENT]: KanbanCardUpdateDetail;
16
  [BEFORE_KANBAN_CARD_DELETE_EVENT]: KanbanCardDeleteDetail;
17
  [KANBAN_CARD_DELETE_EVENT]: KanbanCardDeleteDetail
18
}

`AdditionalData` (Extended from `@revolist/revogrid`)

1
interface AdditionalData {
2
  /** @deprecated Prefer the direct `grid.kanban` property. */
3
      kanban?: KanbanConfig | false
4
}

`HTMLRevoGridElement` (Extended from `global`)

1
interface HTMLRevoGridElement {
2
  kanban?: KanbanConfig | false
3
}

Plugin API

`KanbanPlugin`

Enterprise Kanban presentation for a canonical RevoGrid row source.

Dependencies

Auto-installed EventManagerPlugin, HistoryPlugin: Installs shared edit and history services for atomic Kanban moves.
Auto-installed ContextMenuPlugin: Uses the shared Pro context-menu surface for card actions.
Auto-installed KanbanCardEditorDialogPlugin: Provides the packaged card editor by default while preserving the explicit false opt-out.
Auto-installed FilterPlugin, ColumnMovePlugin: Uses core filtering for cards and core column movement for workflow columns.

1
class KanbanPlugin {
2
  getCards(): readonly T[];
3

4
  getProjection(): KanbanProjection<T> | null;
5

6
  getConfig(): ResolvedKanbanConfig<T> | null;
7

8
  createCard(card: T, options: KanbanCreateOptions = {}): KanbanMutationResult<T>;
9

10
  updateCard(cardId: KanbanCardId, patch: Partial<T>, options: KanbanUpdateOptions = {}): KanbanMutationResult<T>;
11

12
  deleteCards(cardIds: readonly KanbanCardId[], options: KanbanDeleteOptions = {}): KanbanMutationResult<T>;
13

14
  getSelectedCardIds(): readonly KanbanCardId[];
15

16
  setSelectedCardIds(cardIds: readonly KanbanCardId[]): void;
17

18
  getColumnOrder(): readonly KanbanColumnProp[];
19

20
  setColumnOrder(columnProps: readonly KanbanColumnProp[]): void;
21

22
  getCollapsedColumnProps(): readonly KanbanColumnProp[];
23

24
  setColumnCollapsed(columnProp: KanbanColumnProp, collapsed: boolean): void;
25

26
  getSwimlaneColumnCollapsed(): boolean;
27

28
  setSwimlaneColumnCollapsed(collapsed: boolean): void;
29

30
  getDiagnostics(): readonly KanbanDiagnostic<T>[];
31

32
  refresh(): void;
33

34
  moveCards(
35
    cardIds: readonly KanbanCardId[],
36
    target: KanbanMoveTarget,
37
    options: KanbanMoveOptions = {},
38
  ): boolean;
39

40
  requestCreateCard(detail: KanbanCardRequestDetail<T> = {}): void;
41

42
  requestOpenCard(cardId: KanbanCardId): void;
43

44
  requestEditCard(cardId: KanbanCardId): void;
45

46
  requestDeleteCards(cardIds: readonly KanbanCardId[]): void;
47
}

`BEFORE_KANBAN_CARD_MOVE_EVENT`

1
BEFORE_KANBAN_CARD_MOVE_EVENT: string;

`KANBAN_CARD_MOVE_EVENT`

1
KANBAN_CARD_MOVE_EVENT: string;

`KANBAN_SELECTION_CHANGE_EVENT`

1
KANBAN_SELECTION_CHANGE_EVENT: string;

`KANBAN_COLUMN_ORDER_CHANGE_EVENT`

1
KANBAN_COLUMN_ORDER_CHANGE_EVENT: string;

`KANBAN_DROP_STATE_CHANGE_EVENT`

1
KANBAN_DROP_STATE_CHANGE_EVENT: string;

`KANBAN_DIAGNOSTICS_EVENT`

1
KANBAN_DIAGNOSTICS_EVENT: string;

`KANBAN_CARD_CREATE_REQUEST_EVENT`

1
KANBAN_CARD_CREATE_REQUEST_EVENT: string;

`KANBAN_CARD_OPEN_REQUEST_EVENT`

1
KANBAN_CARD_OPEN_REQUEST_EVENT: string;

`KANBAN_CARD_EDIT_REQUEST_EVENT`

1
KANBAN_CARD_EDIT_REQUEST_EVENT: string;

`KANBAN_CARD_DELETE_REQUEST_EVENT`

1
KANBAN_CARD_DELETE_REQUEST_EVENT: string;

`BEFORE_KANBAN_CARD_CREATE_EVENT`

1
BEFORE_KANBAN_CARD_CREATE_EVENT: string;

`KANBAN_CARD_CREATE_EVENT`

1
KANBAN_CARD_CREATE_EVENT: string;

`BEFORE_KANBAN_CARD_UPDATE_EVENT`

1
BEFORE_KANBAN_CARD_UPDATE_EVENT: string;

`KANBAN_CARD_UPDATE_EVENT`

1
KANBAN_CARD_UPDATE_EVENT: string;

`BEFORE_KANBAN_CARD_DELETE_EVENT`

1
BEFORE_KANBAN_CARD_DELETE_EVENT: string;

`KANBAN_CARD_DELETE_EVENT`

1
KANBAN_CARD_DELETE_EVENT: string;

`resolveKanbanLabels`

1
export function resolveKanbanLabels(labels?: Partial<KanbanLabels>): KanbanLabels;

`DEFAULT_KANBAN_LABELS`

1
DEFAULT_KANBAN_LABELS: {
2
  unmappedColumn: string;
3
  implicitSwimlane: string;
4
  emptyColumn: string;
5
  dropCardHere: string;
6
  progress: string;
7
  schedule: string;
8
  assignees: string;
9
  cardCount: (visible: number, total: number) => string;
10
  wipLimit: (count: number, limit: number) => string;
11
  selectedCards: (count: number) => string;
12
  pickedUpCards: (count: number) => string;
13
  moveTarget: (column: string, swimlane: string, position: number) => string;
14
  moveCompleted: (count: number, column: string, swimlane: string) => string;
15
  moveCancelled: string;
16
  currentPosition: string;
17
  noDropTarget: string;
18
  moveBlocked: (reason: string) => string;
19
  noCardsSelected: string;
20
  boardReadOnly: string;
21
  invalidCardIdentity: string;
22
  cardCannotMove: string;
23
  transitionNotAllowed: string;
24
  dropRejected: string;
25
  wipExceeded: (limit: number, excess: number) => string;
26
  moveTargetMissing: string;
27
  selectedCardsMissing: string;
28
  invalidMove: string;
29
  projectionFailed: string;
30
  stackLabel: (column: string, swimlane: string) => string;
31
  readonlyCard: string;
32
  invalidCard: string;
33
  openCard: string;
34
  editCard: string;
35
  moveCard: string;
36
  moveCards: (count: number) => string;
37
  moveToColumn: string;
38
  moveToSwimlane: string;
39
  addCardHere: string;
40
  deleteCard: string;
41
  deleteCards: (count: number) => string;
42
  cardContextMenu: string;
43
  dragHandle: string;
44
  collapseColumn: string;
45
  expandColumn: string;
46
  collapseSwimlane: string;
47
  expandSwimlane: string;
48
  collapseSwimlaneColumn: string;
49
  expandSwimlaneColumn: string;
50
};

`resolveKanbanHistoryConfig`

1
export function resolveKanbanHistoryConfig(history?: HistoryConfig): HistoryConfig;

`isKanbanHistoryConfig`

1
export function isKanbanHistoryConfig(history?: HistoryConfig): boolean;

`KANBAN_HISTORY_RECORD_EVENT`

1
KANBAN_HISTORY_RECORD_EVENT: string;

`KanbanHistoryTool`

1
class KanbanHistoryTool {
2
  isHistoryRecord(detail: EventManagerEvent): boolean;
3

4
  emitPatch(previousCards: readonly T[], nextCards: readonly T[]): boolean;
5

6
  replayPatch(detail: EventManagerEvent): boolean;
7
}

`KanbanLabels`

1
interface KanbanLabels {
2
  readonly unmappedColumn: string;
3
  readonly implicitSwimlane: string;
4
  readonly emptyColumn: string;
5
  readonly dropCardHere: string;
6
  readonly progress: string;
7
  readonly schedule: string;
8
  readonly assignees: string;
9
  readonly cardCount: (visible: number, total: number) => string;
10
  readonly wipLimit: (count: number, limit: number) => string;
11
  readonly selectedCards: (count: number) => string;
12
  readonly pickedUpCards: (count: number) => string;
13
  readonly moveTarget: (column: string, swimlane: string, position: number) => string;
14
  readonly moveCompleted: (count: number, column: string, swimlane: string) => string;
15
  readonly moveCancelled: string;
16
  readonly currentPosition: string;
17
  readonly noDropTarget: string;
18
  readonly moveBlocked: (reason: string) => string;
19
  readonly noCardsSelected: string;
20
  readonly boardReadOnly: string;
21
  readonly invalidCardIdentity: string;
22
  readonly cardCannotMove: string;
23
  readonly transitionNotAllowed: string;
24
  readonly dropRejected: string;
25
  readonly wipExceeded: (limit: number, excess: number) => string;
26
  readonly moveTargetMissing: string;
27
  readonly selectedCardsMissing: string;
28
  readonly invalidMove: string;
29
  readonly projectionFailed: string;
30
  readonly stackLabel: (column: string, swimlane: string) => string;
31
  readonly readonlyCard: string;
32
  readonly invalidCard: string;
33
  readonly openCard: string;
34
  readonly editCard: string;
35
  readonly moveCard: string;
36
  readonly moveCards: (count: number) => string;
37
  readonly moveToColumn: string;
38
  readonly moveToSwimlane: string;
39
  readonly addCardHere: string;
40
  readonly deleteCard: string;
41
  readonly deleteCards: (count: number) => string;
42
  readonly cardContextMenu: string;
43
  /** @deprecated Cards use the whole managed shell as their drag surface. */
44
    readonly dragHandle: string;
45
  readonly collapseColumn: string;
46
  readonly expandColumn: string;
47
  readonly collapseSwimlane: string;
48
  readonly expandSwimlane: string;
49
  readonly collapseSwimlaneColumn: string;
50
  readonly expandSwimlaneColumn: string
51
}

`KanbanCardRuleResult`

1
interface KanbanCardRuleResult {
2
  readonly className?: string;
3
  readonly style?: Readonly<Record<string, string | number>>;
4
  readonly badges?: readonly KanbanBadge[];
5
  readonly draggable?: boolean;
6
  readonly selectable?: boolean;
7
  readonly editable?: boolean
8
}

`KanbanCardRule`

1
interface KanbanCardRule {
2
  readonly id: string;
3
  readonly when: (context: KanbanCardRenderContext<T>) => boolean;
4
  readonly result: KanbanCardRuleResult
5
}

`KanbanDropRuleContext`

1
interface KanbanDropRuleContext {
2
  readonly cards: readonly T[];
3
  readonly sourceColumnProps: readonly KanbanColumnProp[];
4
  readonly targetColumn: KanbanColumnDefinition<T>;
5
  readonly targetSwimlane: KanbanSwimlaneDefinition
6
}

`KanbanRules`

1
interface KanbanRules {
2
  readonly canDrag?: (card: T) => boolean | string;
3
  readonly canSelect?: (card: T) => boolean;
4
  readonly canEdit?: (card: T) => boolean;
5
  readonly canDrop?: (context: KanbanDropRuleContext<T>) => boolean | string
6
}

`KanbanCardConfig`

1
interface KanbanCardConfig {
2
  readonly titleField?: ColumnProp;
3
  readonly descriptionField?: ColumnProp;
4
  readonly title?: (card: T) => string;
5
  readonly description?: (card: T) => string | undefined;
6
  readonly progressField?: ColumnProp;
7
  readonly progress?: (card: T) => number | null | undefined;
8
  readonly startDateField?: ColumnProp;
9
  readonly endDateField?: ColumnProp;
10
  readonly dateRange?: (card: T) => { readonly start: unknown; readonly end: unknown } | null | undefined;
11
  readonly dateTimeZone?: string;
12
  readonly assigneeField?: ColumnProp;
13
  readonly assigneeAvatarField?: ColumnProp;
14
  readonly assignees?: (card: T) => readonly KanbanCardAssignee[];
15
  readonly priorityField?: ColumnProp;
16
  readonly priority?: (card: T) => string | null | undefined;
17
  readonly tagsField?: ColumnProp;
18
  readonly tags?: (card: T) => readonly string[] | null | undefined;
19
  readonly dueDateField?: ColumnProp;
20
  readonly dueDate?: (card: T) => unknown;
21
  readonly colorField?: ColumnProp;
22
  readonly color?: (card: T) => string | null | undefined
23
}

`KanbanFilterConfig`

1
interface KanbanFilterConfig {
2
  readonly query?: string;
3
  readonly fields?: readonly ColumnProp[];
4
  readonly predicate?: (card: T) => boolean
5
}

`KanbanSelectionConfig`

1
interface KanbanSelectionConfig {
2
  readonly mode?: 'single' | 'multiple';
3
  readonly selectedIds?: readonly (string | number)[]
4
}

`KanbanSwimlaneColumnConfig`

1
interface KanbanSwimlaneColumnConfig {
2
  readonly title?: string;
3
  readonly width?: number;
4
  readonly collapsedWidth?: number;
5
  readonly collapsible?: boolean;
6
  readonly collapsed?: boolean
7
}

`KanbanSwimlaneLayout`

Placement of explicit swimlane identity and collapse controls.

1
/** Placement of explicit swimlane identity and collapse controls. */
2
export type KanbanSwimlaneLayout = 'column' | 'top';

`KanbanContextMenuItemId`

1
export type KanbanContextMenuItemId =
2
  /** @deprecated Open is no longer rendered separately from Edit. */
3
  | 'open'
4
  | 'edit'
5
  | 'move'
6
  | 'create'
7
  | 'delete';

`KanbanContextMenuItemContext`

1
interface KanbanContextMenuItemContext {
2
  /** Primary card whose shell opened the menu. */
3
    readonly card: T;
4
  /** Full invoked selection, or only the primary card when it was not selected. */
5
    readonly cardIds: readonly KanbanCardId[];
6
  readonly column: KanbanColumnDefinition<T>;
7
  readonly swimlane: KanbanSwimlaneDefinition
8
}

`KanbanContextMenuItemVisibility`

1
export type KanbanContextMenuItemVisibility<T extends DataType = DataType> =
2
  | boolean
3
  | ((context: KanbanContextMenuItemContext<T>) => boolean);

`KanbanConfig`

1
interface KanbanConfig {
2
  readonly columns?: readonly KanbanColumnDefinition<T>[];
3
  readonly idField?: ColumnProp;
4
  readonly columnField?: ColumnProp;
5
  readonly orderField?: ColumnProp;
6
  readonly swimlaneField?: ColumnProp;
7
  readonly swimlanes?: readonly KanbanSwimlaneDefinition[];
8
  /** Render swimlane identity in a row-header column or above each lane. @default 'column' */
9
    readonly swimlaneLayout?: KanbanSwimlaneLayout;
10
  /** Swimlane row-header presentation. Set to `false` to hide it. */
11
    readonly swimlaneColumn?: KanbanSwimlaneColumnConfig | false;
12
  /** Built-in card context menu. Enabled by default. */
13
    readonly contextMenu?: KanbanContextMenuConfig<T> | false;
14
  readonly readOnly?: boolean;
15
  readonly wipBehavior?: 'warn' | 'block';
16
  readonly rules?: KanbanRules<T>;
17
  readonly cardRules?: readonly KanbanCardRule<T>[];
18
  readonly selection?: KanbanSelectionConfig;
19
  readonly card?: KanbanCardConfig<T>;
20
  readonly customization?: KanbanCustomization<T>;
21
  readonly filter?: KanbanFilterConfig<T>;
22
  readonly labels?: Partial<KanbanLabels>;
23
  readonly locale?: string;
24
  /** Uniform projected row height reserved for each card. */
25
    readonly cardRowHeight?: number;
26
  /** @deprecated Use `cardRowHeight`. Retained as a compatibility alias. */
27
    readonly laneHeight?: number;
28
  readonly collapsedLaneHeight?: number;
29
  readonly cardGap?: number;
30
  readonly unmappedColumn?: boolean
31
}

`ResolvedKanbanConfig` (Extended from `index.ts`)

1
interface ResolvedKanbanConfig {
2
  readonly columns: readonly KanbanColumnDefinition<T>[];
3
  readonly idField: ColumnProp;
4
  readonly columnField: ColumnProp;
5
  readonly orderField: ColumnProp;
6
  readonly wipBehavior: 'warn' | 'block';
7
  readonly selection: Required<KanbanSelectionConfig>;
8
  readonly card: Required<Pick<KanbanCardConfig<T>, 'titleField'>> & KanbanCardConfig<T>;
9
  readonly locale: string;
10
  readonly cardRowHeight: number;
11
  readonly laneHeight: number;
12
  readonly collapsedLaneHeight: number;
13
  readonly swimlaneLayout: KanbanSwimlaneLayout;
14
  readonly swimlaneColumn: Required<KanbanSwimlaneColumnConfig> & { readonly enabled: boolean };
15
  readonly contextMenu: false | Required<Pick<KanbanContextMenuConfig<T>, 'includeHostItems'>> & KanbanContextMenuConfig<T>;
16
  readonly cardGap: number;
17
  readonly unmappedColumn: boolean
18
}

`KanbanCardMoveDetail`

1
interface KanbanCardMoveDetail {
2
  readonly cardIds: readonly KanbanCardId[];
3
  readonly cards: readonly T[];
4
  /** Every canonical card changed by the move, including rank rebalances. */
5
    readonly changedCards: readonly T[];
6
  readonly previousCards: readonly T[];
7
  readonly previousLocations: readonly KanbanCardLocation[];
8
  readonly currentLocations: readonly KanbanCardLocation[];
9
  readonly target: KanbanMoveTarget;
10
  readonly reason: 'pointer' | 'keyboard' | 'api' | 'history';
11
  readonly rebalancedCardIds: readonly KanbanCardId[]
12
}

`KanbanBeforeCardMoveDetail` (Extended from `index.ts`)

1
interface KanbanBeforeCardMoveDetail {
2
  readonly proposedCards: readonly T[]
3
}

`KanbanSelectionChangeDetail`

1
interface KanbanSelectionChangeDetail {
2
  readonly cardIds: readonly KanbanCardId[];
3
  readonly cards: readonly T[];
4
  readonly mode: 'replace' | 'toggle' | 'range' | 'clear' | 'api'
5
}

`KanbanColumnOrderChangeDetail`

1
interface KanbanColumnOrderChangeDetail {
2
  readonly columnProps: readonly KanbanColumnProp[];
3
  readonly reason: 'drag' | 'api'
4
}

`KanbanDropStateChangeDetail`

1
interface KanbanDropStateChangeDetail {
2
  readonly cardIds: readonly KanbanCardId[];
3
  readonly target?: KanbanMoveTarget;
4
  readonly valid: boolean;
5
  /** Distinguishes actionable, blocked, and order-preserving pointer targets. */
6
    readonly state?: 'valid' | 'invalid' | 'noop';
7
  readonly reason?: string
8
}

`KanbanDiagnosticsDetail`

1
interface KanbanDiagnosticsDetail {
2
  readonly diagnostics: readonly KanbanDiagnostic<T>[]
3
}

`KanbanCardRequestDetail`

1
interface KanbanCardRequestDetail {
2
  readonly cardId?: KanbanCardId;
3
  readonly card?: T;
4
  readonly cardIds?: readonly KanbanCardId[];
5
  readonly cards?: readonly T[];
6
  readonly columnProp?: KanbanColumnProp;
7
  readonly swimlaneId?: KanbanSwimlaneId
8
}

`KanbanMutationReason`

1
export type KanbanMutationReason = 'api' | 'editor' | 'history';

`KanbanCardCreateDetail`

1
interface KanbanCardCreateDetail {
2
  readonly card: T;
3
  readonly cardId: KanbanCardId;
4
  readonly sourceIndex: number;
5
  readonly reason: KanbanMutationReason
6
}

`KanbanCardUpdateDetail`

1
interface KanbanCardUpdateDetail {
2
  readonly card: T;
3
  readonly previousCard: T;
4
  readonly cardId: KanbanCardId;
5
  readonly sourceIndex: number;
6
  readonly reason: KanbanMutationReason
7
}

`KanbanCardDeleteDetail`

1
interface KanbanCardDeleteDetail {
2
  readonly cards: readonly T[];
3
  readonly cardIds: readonly KanbanCardId[];
4
  readonly sourceIndexes: readonly number[];
5
  readonly reason: KanbanMutationReason
6
}

`KanbanMutationResult`

1
export type KanbanMutationResult<T extends DataType = DataType> =
2
  | { readonly ok: true; readonly cards: readonly T[]; readonly cardIds: readonly KanbanCardId[] }
3
  | { readonly ok: false; readonly reason: string; readonly code: 'inactive' | 'readonly' | 'invalid' | 'duplicate' | 'missing' | 'rule' | 'cancelled' };

`KanbanCardId`

1
export type KanbanCardId = string | number;

`KanbanColumnProp`

1
export type KanbanColumnProp = ColumnProp;

`KanbanSwimlaneId`

1
export type KanbanSwimlaneId = string | number;

`KanbanCardLocation`

1
interface KanbanCardLocation {
2
  readonly columnProp: KanbanColumnProp;
3
  readonly swimlaneId: KanbanSwimlaneId;
4
  readonly index: number;
5
  readonly rank: number
6
}

`KanbanColumnDefinition`

1
interface KanbanColumnDefinition {
2
  readonly prop: KanbanColumnProp;
3
  readonly name?: string;
4
  readonly size?: number;
5
  readonly minSize?: number;
6
  readonly maxSize?: number;
7
  readonly columnTemplate?: KanbanColumnTemplate<T>;
8
  readonly columnProperties?: KanbanColumnProperties<T>;
9
  readonly wipLimit?: number;
10
  readonly collapsed?: boolean;
11
  readonly collapsible?: boolean;
12
  readonly allowedFrom?: readonly KanbanColumnProp[];
13
  readonly metadata?: Readonly<Record<string, unknown>>;
14
  readonly cardFilter?: (card: T) => boolean
15
}

`KanbanColumnHeaderRenderContext`

1
interface KanbanColumnHeaderRenderContext {
2
  readonly column: KanbanColumnDefinition<T>;
3
  readonly visibleCount: number;
4
  readonly totalCount: number;
5
  readonly overWipLimit: boolean;
6
  readonly toggleCollapsed: () => void
7
}

`KanbanColumnTemplateProp` (Extended from `index.ts`)

1
interface KanbanColumnTemplateProp {
2
  readonly kanban: KanbanColumnHeaderRenderContext<T>
3
}

`KanbanColumnTemplate`

1
export type KanbanColumnTemplate<T extends DataType = DataType> = (
2
  createElement: HyperFunc<VNode>,
3
  props: KanbanColumnTemplateProp<T>,
4
  additionalData?: any,
5
) => any;

`KanbanColumnProperties`

1
export type KanbanColumnProperties<T extends DataType = DataType> = (
2
  props: KanbanColumnTemplateProp<T>,
3
) => CellProps | void | undefined;

`KanbanSwimlaneDefinition`

1
interface KanbanSwimlaneDefinition {
2
  readonly id: KanbanSwimlaneId;
3
  readonly title: string;
4
  readonly height?: number;
5
  readonly collapsed?: boolean;
6
  readonly collapsible?: boolean;
7
  readonly wipLimits?: Readonly<Record<string, number>>;
8
  readonly className?: string;
9
  readonly style?: Readonly<Record<string, string | number>>;
10
  readonly metadata?: Readonly<Record<string, unknown>>
11
}

`KanbanDiagnosticCode`

1
export type KanbanDiagnosticCode =
2
  | 'duplicate-column-prop'
3
  | 'missing-card-id'
4
  | 'duplicate-card-id'
5
  | 'invalid-rank'
6
  | 'unknown-column'
7
  | 'unknown-swimlane';

`KanbanDiagnostic`

1
interface KanbanDiagnostic {
2
  readonly code: KanbanDiagnosticCode;
3
  readonly message: string;
4
  readonly card?: T;
5
  readonly cardIndex?: number;
6
  readonly value?: unknown;
7
  readonly blocking: boolean
8
}

`KanbanProjectedCard`

1
interface KanbanProjectedCard {
2
  readonly id: KanbanCardId;
3
  readonly card: T;
4
  readonly sourceIndex: number;
5
  readonly location: KanbanCardLocation;
6
  readonly mutable: boolean
7
}

`KanbanGridRow` (Extended from `index.ts`)

1
interface KanbanGridRow {
2
  readonly __kanbanRow: true;
3
  readonly __kanbanLaneId: KanbanSwimlaneId;
4
  readonly __kanbanLaneTitle: string;
5
  readonly __kanbanLaneCollapsed: boolean;
6
  /** Dedicated lane identity row rendered across the workflow viewport. */
7
    readonly __kanbanLaneHeaderRow: boolean;
8
  readonly __kanbanLaneRowIndex: number;
9
  readonly __kanbanLaneRowCount: number;
10
  readonly __kanbanDropRow: boolean;
11
  readonly __kanbanCardsByColumn: Readonly<Record<string, readonly KanbanProjectedCard<T>[]>>
12
}

`KanbanProjection`

1
interface KanbanProjection {
2
  readonly cards: readonly KanbanProjectedCard<T>[];
3
  readonly rows: readonly KanbanGridRow<T>[];
4
  readonly columns: readonly KanbanColumnDefinition<T>[];
5
  readonly swimlanes: readonly KanbanSwimlaneDefinition[];
6
  readonly diagnostics: readonly KanbanDiagnostic<T>[];
7
  readonly visibleCardIds: ReadonlySet<KanbanCardId>;
8
  readonly cardById: ReadonlyMap<KanbanCardId, KanbanProjectedCard<T>>;
9
  readonly totalCounts: ReadonlyMap<string, number>;
10
  readonly visibleCounts: ReadonlyMap<string, number>
11
}

`KanbanMoveTarget`

1
interface KanbanMoveTarget {
2
  readonly columnProp: KanbanColumnProp;
3
  readonly swimlaneId?: KanbanSwimlaneId;
4
  /** Full-bucket insertion index. Omit to append. */
5
    readonly index?: number;
6
  /** Visible card before which the batch should be inserted. */
7
    readonly beforeCardId?: KanbanCardId
8
}

`KanbanMoveOptions`

1
interface KanbanMoveOptions {
2
  readonly reason?: 'pointer' | 'keyboard' | 'api' | 'history';
3
  readonly skipHistory?: boolean
4
}

`KanbanCreateOptions`

1
interface KanbanCreateOptions {
2
  readonly columnProp?: KanbanColumnProp;
3
  readonly swimlaneId?: KanbanSwimlaneId;
4
  readonly sourceIndex?: number;
5
  readonly reason?: 'api' | 'editor' | 'history';
6
  readonly skipHistory?: boolean
7
}

`KanbanUpdateOptions`

1
interface KanbanUpdateOptions {
2
  readonly reason?: 'api' | 'editor' | 'history';
3
  readonly skipHistory?: boolean
4
}

`KanbanDeleteOptions` (Extended from `index.ts`)

1
interface KanbanDeleteOptions {
2

3
}

`KanbanField`

1
export type KanbanField = ColumnProp;

`KanbanTemplateResult`

1
export type KanbanTemplateResult = VNode | string | number | null | undefined;

`KanbanTemplateH`

1
export type KanbanTemplateH = (
2
  tag: string,
3
  props?: Record<string, unknown>,
4
  children?: unknown,
5
) => VNode;

`KanbanBadge`

1
interface KanbanBadge {
2
  readonly label: string;
3
  readonly className?: string;
4
  readonly title?: string
5
}

`KanbanCardAssignee`

1
interface KanbanCardAssignee {
2
  readonly id?: string | number;
3
  readonly label: string;
4
  readonly avatar?: unknown
5
}

`KanbanProgressRenderOptions`

1
interface KanbanProgressRenderOptions {
2
  readonly value: number;
3
  readonly label: string;
4
  readonly className?: string;
5
  readonly showValue?: boolean
6
}

`KanbanAssigneesRenderOptions`

1
interface KanbanAssigneesRenderOptions {
2
  readonly assignees: readonly KanbanCardAssignee[];
3
  readonly label: string;
4
  readonly className?: string;
5
  readonly maxVisible?: number;
6
  readonly avatarSize?: number
7
}

`KanbanDateRangeRenderOptions`

1
interface KanbanDateRangeRenderOptions {
2
  readonly start: unknown;
3
  readonly end: unknown;
4
  readonly label: string;
5
  readonly locale?: string;
6
  readonly timeZone?: string;
7
  readonly className?: string
8
}

`KanbanCardRenderContext`

1
interface KanbanCardRenderContext {
2
  readonly projectedCard: KanbanProjectedCard<T>;
3
  readonly card: T;
4
  readonly column: KanbanColumnDefinition<T>;
5
  readonly swimlane: KanbanSwimlaneDefinition;
6
  readonly selected: boolean;
7
  readonly dragging: boolean;
8
  readonly readonly: boolean;
9
  readonly badges: readonly KanbanBadge[]
10
}

`KanbanSwimlaneHeaderRenderContext`

1
interface KanbanSwimlaneHeaderRenderContext {
2
  readonly swimlane: KanbanSwimlaneDefinition;
3
  readonly visibleCount: number;
4
  readonly totalCount: number;
5
  readonly swimlaneColumnCollapsed: boolean
6
}

`KanbanSwimlaneColumnHeaderRenderContext`

1
interface KanbanSwimlaneColumnHeaderRenderContext {
2
  readonly collapsed: boolean
3
}

`KanbanCustomization`

1
interface KanbanCustomization {
2
  readonly cardContent?: (h: KanbanTemplateH, context: KanbanCardRenderContext<T>) => KanbanTemplateResult;
3
  readonly cardProps?: (context: KanbanCardRenderContext<T>) => Record<string, unknown> | undefined;
4
  readonly dragPreview?: (h: KanbanTemplateH, context: KanbanCardRenderContext<T>) => KanbanTemplateResult;
5
  readonly swimlaneHeader?: (h: KanbanTemplateH, context: KanbanSwimlaneHeaderRenderContext) => KanbanTemplateResult;
6
  readonly swimlaneColumnHeader?: (h: KanbanTemplateH, context: KanbanSwimlaneColumnHeaderRenderContext) => KanbanTemplateResult;
7
  readonly emptyState?: (h: KanbanTemplateH, context: { column: KanbanColumnDefinition<T>; swimlane: KanbanSwimlaneDefinition }) => KanbanTemplateResult
8
}

`cardMatchesKanbanFilter`

1
export function cardMatchesKanbanFilter<T extends DataType>(
2
  card: T,
3
  config: Pick<ResolvedKanbanConfig<T>, 'card' | 'filter' | 'locale'>,
4
): boolean;

`filterKanbanCards`

1
export function filterKanbanCards<T extends DataType>(
2
  cards: readonly T[],
3
  config: Pick<ResolvedKanbanConfig<T>, 'card' | 'filter' | 'locale'>,
4
  externalPredicate?: (card: T, sourceIndex: number) => boolean,
5
): readonly T[];

`withKanbanQuery`

1
export function withKanbanQuery<T extends DataType>(
2
  filter: KanbanFilterConfig<T> | undefined,
3
  query: string,
4
): KanbanFilterConfig<T>;

`kanbanIdKey`

Keeps numeric and string identifiers distinct in maps and serialized row fields.

1
export function kanbanIdKey(id: KanbanIdentity): string;

`kanbanBucketKey`

1
export function kanbanBucketKey(columnProp: KanbanColumnProp, swimlaneId: KanbanSwimlaneId): string;

`resolveKanbanColumnName`

1
export function resolveKanbanColumnName<T extends DataType>(column: KanbanColumnDefinition<T>): string;

`readKanbanField`

1
export function readKanbanField<T extends DataType>(card: T, field: ColumnProp): unknown;

`writeKanbanFields`

1
export function writeKanbanFields<T extends DataType>(
2
  card: T,
3
  patch: ReadonlyMap<ColumnProp, unknown>,
4
): T;

`isKanbanId`

1
export function isKanbanId(value: unknown): value is KanbanIdentity;

`KanbanIdentity`

1
export type KanbanIdentity = KanbanCardId | KanbanColumnProp | KanbanSwimlaneId;

`isKanbanMoveNoop`

Returns true when a proposed drop preserves the complete destination order.

1
export function isKanbanMoveNoop<T extends DataType>(
2
  options: IsKanbanMoveNoopOptions<T>,
3
): boolean;

`moveKanbanCards`

Produces one immutable, all-or-nothing canonical card move.

1
export function moveKanbanCards<T extends DataType>(
2
  options: MoveKanbanCardsOptions<T>,
3
): KanbanMoveMutationResult<T>;

`getKanbanMoveBucketKey`

1
export function getKanbanMoveBucketKey(target: KanbanMoveTarget): string;

`MoveKanbanCardsOptions`

1
interface MoveKanbanCardsOptions {
2
  readonly cards: readonly T[];
3
  readonly projection: KanbanProjection<T>;
4
  readonly config: KanbanConfig<T> | ResolvedKanbanConfig<T>;
5
  readonly cardIds: readonly KanbanCardId[];
6
  readonly target: KanbanMoveTarget
7
}

`KanbanMoveMutationSuccess`

1
interface KanbanMoveMutationSuccess {
2
  readonly ok: true;
3
  readonly cards: readonly T[];
4
  readonly movedCardIds: readonly KanbanCardId[];
5
  readonly movedCards: readonly T[];
6
  readonly previousCards: readonly T[];
7
  readonly previousLocations: readonly KanbanCardLocation[];
8
  readonly currentLocations: readonly KanbanCardLocation[];
9
  readonly changedCards: readonly T[];
10
  readonly rebalancedCardIds: readonly KanbanCardId[];
11
  readonly validation: KanbanDropValidation;
12
  readonly projection: KanbanProjection<T>
13
}

`KanbanMoveMutationFailure`

1
interface KanbanMoveMutationFailure {
2
  readonly ok: false;
3
  readonly cards: readonly T[];
4
  readonly reason: string;
5
  readonly validation?: KanbanDropValidation
6
}

`KanbanMoveMutationResult`

1
export type KanbanMoveMutationResult<T extends DataType = DataType> =
2
  | KanbanMoveMutationSuccess<T>
3
  | KanbanMoveMutationFailure<T>;

`IsKanbanMoveNoopOptions`

1
export type IsKanbanMoveNoopOptions<T extends DataType = DataType> = Pick<
2
  MoveKanbanCardsOptions<T>,
3
  'projection' | 'cardIds' | 'target'
4
>;

`resolveKanbanConfig`

1
export function resolveKanbanConfig<T extends DataType>(config: KanbanConfig<T>): ResolvedKanbanConfig<T>;

`normalizeKanbanBoard`

1
export function normalizeKanbanBoard<T extends DataType>(
2
  cards: readonly T[],
3
  config: KanbanConfig<T>,
4
): NormalizedKanbanBoard<T>;

`orderKanbanColumns`

Orders known workflow columns by runtime preference and appends omitted columns stably.

1
export function orderKanbanColumns<T extends DataType>(
2
  columns: readonly KanbanColumnDefinition<T>[],
3
  columnOrder: readonly KanbanColumnProp[],
4
): readonly KanbanColumnDefinition<T>[];

`KANBAN_IMPLICIT_SWIMLANE_ID`

1
KANBAN_IMPLICIT_SWIMLANE_ID: string;

`KANBAN_UNMAPPED_COLUMN_PROP`

1
KANBAN_UNMAPPED_COLUMN_PROP: string;

`NormalizedKanbanBoard`

1
interface NormalizedKanbanBoard {
2
  readonly config: ResolvedKanbanConfig<T>;
3
  readonly columns: readonly KanbanColumnDefinition<T>[];
4
  readonly swimlanes: readonly KanbanSwimlaneDefinition[];
5
  readonly diagnostics: readonly KanbanDiagnostic<T>[]
6
}

`createKanbanProjection`

1
export function createKanbanProjection<T extends DataType>(
2
  cards: readonly T[],
3
  config: KanbanConfig<T> | ResolvedKanbanConfig<T>,
4
  options: CreateKanbanProjectionOptions<T> = {},
5
): KanbanProjection<T>;

`getKanbanBucketCards`

1
export function getKanbanBucketCards<T extends DataType>(
2
  projection: KanbanProjection<T>,
3
  columnProp: KanbanColumnProp,
4
  swimlaneId: string | number,
5
  visibleOnly = false,
6
): readonly KanbanProjectedCard<T>[];

`getKanbanBoardOrder`

1
export function getKanbanBoardOrder<T extends DataType>(projection: KanbanProjection<T>): readonly KanbanCardId[];

`CreateKanbanProjectionOptions`

1
interface CreateKanbanProjectionOptions {
2
  /** Physical canonical indexes that passed an external filter. */
3
    readonly externallyVisibleSourceIndexes?: ReadonlySet<number>;
4
  /** @deprecated Prefer source indexes so invalid and duplicate card ids remain distinguishable. */
5
    readonly externallyVisibleCardIds?: ReadonlySet<KanbanCardId>;
6
  readonly isExternallyVisible?: (card: T, sourceIndex: number) => boolean
7
}

`allocateFractionalRanks`

Allocates ordered ranks in a gap, or returns undefined when the bucket must be rebalanced.

1
export function allocateFractionalRanks(options: AllocateKanbanRanksOptions): readonly number[] | undefined;

`createRebalancedKanbanRanks`

1
export function createRebalancedKanbanRanks<T extends DataType>(
2
  cards: readonly Pick<KanbanProjectedCard<T>, 'id'>[],
3
  spacing = KANBAN_RANK_SPACING,
4
): ReadonlyMap<KanbanCardId, number>;

`KANBAN_RANK_SPACING`

1
KANBAN_RANK_SPACING: 1024;

`AllocateKanbanRanksOptions`

1
interface AllocateKanbanRanksOptions {
2
  readonly beforeRank?: number;
3
  readonly afterRank?: number;
4
  readonly count: number;
5
  readonly spacing?: number;
6
  readonly minimumGap?: number
7
}

`resolveKanbanCardRuleState`

1
export function resolveKanbanCardRuleState<T extends DataType>(
2
  options: ResolveKanbanCardRuleOptions<T>,
3
): ResolvedKanbanCardRuleState;

`validateKanbanDrop`

1
export function validateKanbanDrop<T extends DataType>(
2
  options: ValidateKanbanDropOptions<T>,
3
): KanbanDropValidation;

`ResolvedKanbanCardRuleState`

1
interface ResolvedKanbanCardRuleState {
2
  readonly classNames: readonly string[];
3
  readonly style: Readonly<Record<string, string | number>>;
4
  readonly badges: readonly KanbanBadge[];
5
  readonly draggable: boolean;
6
  readonly selectable: boolean;
7
  readonly editable: boolean
8
}

`ValidateKanbanDropOptions`

1
interface ValidateKanbanDropOptions {
2
  readonly config: KanbanConfig<T> | ResolvedKanbanConfig<T>;
3
  readonly cards: readonly KanbanProjectedCard<T>[];
4
  readonly targetColumn: KanbanColumnDefinition<T>;
5
  readonly targetSwimlane: KanbanSwimlaneDefinition;
6
  /** Canonical count in the target column across every swimlane. */
7
    readonly targetColumnTotalCount?: number;
8
  /** Canonical count in the target column/swimlane bucket. */
9
    readonly targetTotalCount: number
10
}

`KanbanDropValidation`

1
interface KanbanDropValidation {
2
  readonly valid: boolean;
3
  readonly reason?: string;
4
  readonly warning?: string;
5
  readonly projectedCount: number;
6
  readonly wipLimit?: number
7
}

`uniqueKanbanCardIds`

1
export function uniqueKanbanCardIds(ids: Iterable<KanbanCardId>): KanbanCardId[];

`pruneKanbanSelection`

1
export function pruneKanbanSelection(
2
  selectedIds: readonly KanbanCardId[],
3
  allowedIds: ReadonlySet<KanbanCardId> | readonly KanbanCardId[],
4
): readonly KanbanCardId[];

`updateKanbanSelection`

1
export function updateKanbanSelection(options: UpdateKanbanSelectionOptions): readonly KanbanCardId[];

`KanbanSelectionMode`

1
export type KanbanSelectionMode = 'replace' | 'toggle' | 'range' | 'clear' | 'api';

`UpdateKanbanSelectionOptions`

1
interface UpdateKanbanSelectionOptions {
2
  readonly currentIds: readonly KanbanCardId[];
3
  readonly cardId?: KanbanCardId;
4
  readonly mode: KanbanSelectionMode;
5
  readonly orderedCardIds: readonly KanbanCardId[];
6
  readonly anchorId?: KanbanCardId;
7
  readonly selectionMode?: 'single' | 'multiple'
8
}

`renderKanbanDateRange`

Renders a compact locale-aware schedule shared by default and custom cards.

1
export function renderKanbanDateRange(
2
  h: KanbanTemplateH,
3
  options: KanbanDateRangeRenderOptions,
4
): KanbanTemplateResult;

`renderKanbanProgress`

Renders compact, theme-aware progress content for managed or custom cards.

1
export function renderKanbanProgress(
2
  h: KanbanTemplateH,
3
  options: KanbanProgressRenderOptions,
4
): KanbanTemplateResult;

`renderKanbanAssignees`

Renders assignees with the shared Pro avatar component.

1
export function renderKanbanAssignees(
2
  h: KanbanTemplateH,
3
  options: KanbanAssigneesRenderOptions,
4
): KanbanTemplateResult;

`createKanbanColumns`

1
export function createKanbanColumns<T extends DataType>(
2
  projection: KanbanProjection<T>,
3
): KanbanGridColumn<T>[];

`createKanbanColumnTypes`

1
export function createKanbanColumnTypes<T extends DataType>(
2
  options: KanbanColumnTypeOptions<T>,
3
): Record<string, ColumnType<DataType>>;

`createKanbanRowHeaders`

1
export function createKanbanRowHeaders<T extends DataType>(
2
  options: KanbanColumnTypeOptions<T>,
3
): RowHeaders;

`KANBAN_COLUMN_TYPE`

1
KANBAN_COLUMN_TYPE: string;

`KanbanGridColumn` (Extended from `index.ts`)

1
interface KanbanGridColumn {
2

3
}

`installKanbanDependencies`

1
export function installKanbanDependencies(
2
  grid: HTMLRevoGridElement,
3
  providers: PluginProviders,
4
): KanbanInstalledDependencies;

`KanbanInstalledDependencies`

1
interface KanbanInstalledDependencies {
2
  activate(): void;
3
  deactivate(): void;
4
  destroy(): void
5
}

`KanbanGridSync`

1
class KanbanGridSync {
2
  initialize(): void;
3

4
  applyProjection(
5
    projection: KanbanProjection<T>,
6
    options: { readonly applyColumns?: boolean } = {},
7
  ): void;
8

9
  captureSource(source: readonly T[]): void;
10

11
  captureColumns(columns: readonly (ColumnGrouping | ColumnRegular)[]): void;
12

13
  restore(source?: readonly T[]): void;
14

15
  isApplyingSource(): boolean;
16

17
  isApplyingColumns(): boolean;
18

19
  refresh(): void;
20
}

`renderKanbanCard`

1
export function renderKanbanCard<T extends DataType>(
2
  h: KanbanTemplateH,
3
  projectedCard: KanbanProjectedCard<T>,
4
  column: KanbanColumnDefinition<T>,
5
  swimlane: KanbanSwimlaneDefinition,
6
  options: KanbanColumnTypeOptions<T>,
7
  index: number,
8
);

`KanbanRendererActions`

1
interface KanbanRendererActions {
2
  readonly getSelectedCardIds: () => readonly KanbanCardId[];
3
  readonly getDraggingCardIds?: () => readonly KanbanCardId[];
4
  readonly onCardSelect: (event: MouseEvent | KeyboardEvent, cardId: KanbanCardId) => void;
5
  readonly onCardPointerDown: (event: PointerEvent, cardId: KanbanCardId, element: HTMLElement) => void;
6
  readonly onCardKeyDown: (event: KeyboardEvent, cardId: KanbanCardId) => void;
7
  readonly onCardEditRequest: (cardId: KanbanCardId) => void;
8
  readonly onColumnToggle?: (columnProp: KanbanColumnProp) => void;
9
  readonly onSwimlaneToggle?: (swimlaneId: string | number) => void;
10
  readonly isSwimlaneColumnCollapsed?: () => boolean;
11
  readonly onSwimlaneColumnToggle?: () => void;
12
  readonly onMoveRequest?: (cardIds: readonly KanbanCardId[], target: KanbanMoveTarget) => void
13
}

`KanbanColumnTypeOptions`

1
interface KanbanColumnTypeOptions {
2
  readonly getProjection: () => KanbanProjection<T> | null;
3
  readonly getConfig: () => KanbanConfig<T> | ResolvedKanbanConfig<T>;
4
  readonly getLabels: () => KanbanLabels;
5
  readonly actions: KanbanRendererActions<T>
6
}

`KanbanContextMenuControllerOptions`

1
interface KanbanContextMenuControllerOptions {
2
  readonly grid: HTMLRevoGridElement;
3
  readonly getProjection: () => KanbanProjection<T> | null;
4
  readonly getConfig: () => ResolvedKanbanConfig<T> | null;
5
  readonly getLabels: () => KanbanLabels;
6
  readonly getSelectedCardIds: () => readonly KanbanCardId[];
7
  readonly canEditCard: (cardId: KanbanCardId) => boolean;
8
  readonly validateMove: (
9
      cardIds: readonly KanbanCardId[],
10
      target: KanbanMoveTarget,
11
    ) => true | string | { readonly valid: true; readonly warning: string };
12
  readonly moveCards: (cardIds: readonly KanbanCardId[], target: KanbanMoveTarget) => void;
13
  readonly requestEditCard: (cardId: KanbanCardId) => void;
14
  readonly requestCreateCard: (detail: KanbanCardRequestDetail<T>) => void;
15
  readonly requestDeleteCards: (cardIds: readonly KanbanCardId[]) => void
16
}

`KanbanContextMenuController`

Composes card actions into the shared Pro context-menu surface.

1
class KanbanContextMenuController {
2
  apply(): void;
3

4
  remove(): void;
5
}

`toDomCardId`

1
export function toDomCardId(value: KanbanCardId): string;

`KanbanDomDropTarget` (Extended from `index.ts`)

1
interface KanbanDomDropTarget {
2
  readonly element: HTMLElement;
3
  readonly anchorElement?: HTMLElement
4
}

`KanbanDropVisualState`

1
export type KanbanDropVisualState = 'valid' | 'invalid' | 'noop';

`KanbanDomLayer`

Owns the small amount of DOM state required by pointer drag and drop.

1
class KanbanDomLayer {
2
  hitTest(clientX: number, clientY: number): KanbanDomDropTarget | undefined;
3

4
  createPreview(source: HTMLElement, count: number): void;
5

6
  movePreview(clientX: number, clientY: number): void;
7

8
  showIndicator(target: KanbanDomDropTarget, state: KanbanDropVisualState): void;
9

10
  clearDropFeedback(): void;
11

12
  autoScroll(clientX: number, clientY: number, margin = 48, speed = 18): boolean;
13

14
  clear(): void;
15

16
  focusCardHandle(cardId: KanbanCardId, fallbackTarget?: KanbanMoveTarget): void;
17
}

`KanbanKeyboardPosition` (Extended from `index.ts`)

1
interface KanbanKeyboardPosition {
2
  readonly columnName: string;
3
  readonly swimlaneTitle: string
4
}

`KanbanKeyboardControllerOptions`

1
interface KanbanKeyboardControllerOptions {
2
  readonly getSelectedCardIds: () => readonly KanbanCardId[];
3
  readonly selectForDrag: (cardId: KanbanCardId) => void;
4
  readonly getPositions: () => readonly KanbanKeyboardPosition[];
5
  readonly announce: (message: string) => void;
6
  readonly pickedUpLabel: (count: number) => string;
7
  readonly targetLabel: (position: KanbanKeyboardPosition) => string;
8
  readonly cancelledLabel: () => string;
9
  readonly onStateChange?: () => void;
10
  readonly onMove: (cardIds: readonly KanbanCardId[], target: KanbanMoveTarget, reason: 'keyboard') => void | Promise<void>
11
}

`KanbanKeyboardController`

1
class KanbanKeyboardController {
2
  keyDown(event: KeyboardEvent, cardId: KanbanCardId): boolean;
3

4
  cancel(): void;
5

6
  getActiveCardIds(): readonly KanbanCardId[];
7
}

`KanbanLiveRegion`

1
class KanbanLiveRegion {
2
  mount(): void;
3

4
  announce(message: string): void;
5

6
  destroy(): void;
7
}

`KanbanPointerDropState`

1
interface KanbanPointerDropState {
2
  readonly cardIds: readonly KanbanCardId[];
3
  readonly target?: KanbanMoveTarget;
4
  readonly valid: boolean;
5
  readonly state: KanbanDropVisualState;
6
  readonly reason?: string
7
}

`KanbanPointerControllerOptions`

1
interface KanbanPointerControllerOptions {
2
  readonly getSelectedCardIds: () => readonly KanbanCardId[];
3
  readonly selectForDrag: (cardId: KanbanCardId) => void;
4
  readonly validateTarget?: (
5
      cardIds: readonly KanbanCardId[],
6
      target: KanbanMoveTarget,
7
    ) => true | string | { readonly valid: true; readonly warning: string };
8
  readonly isNoopTarget?: (cardIds: readonly KanbanCardId[], target: KanbanMoveTarget) => boolean;
9
  readonly getNoopReason?: () => string;
10
  readonly getNoTargetReason?: () => string;
11
  readonly onDropStateChange?: (state: KanbanPointerDropState) => void;
12
  readonly announceValidation?: (message: string) => void;
13
  readonly onMove: (cardIds: readonly KanbanCardId[], target: KanbanMoveTarget, reason: 'pointer') => void | Promise<void>
14
}

`KanbanPointerController`

1
class KanbanPointerController {
2
  pointerDown(event: PointerEvent, cardId: KanbanCardId, source: HTMLElement): void;
3

4
  cancel(): void;
5

6
  getDraggingCardIds(): readonly KanbanCardId[];
7

8
  consumeSuppressedClick(cardId: KanbanCardId): boolean;
9

10
  destroy(): void;
11
}

`KanbanSelectionUpdate`

1
interface KanbanSelectionUpdate {
2
  readonly cardIds: readonly KanbanCardId[];
3
  readonly mode: KanbanSelectionMode
4
}

`KanbanSelectionController`

1
class KanbanSelectionController {
2
  get(): readonly KanbanCardId[];
3

4
  has(id: KanbanCardId): boolean;
5

6
  set(ids: readonly KanbanCardId[], mode: KanbanSelectionMode = 'api'): void;
7

8
  clear(mode: KanbanSelectionMode = 'clear'): void;
9

10
  select(
11
    id: KanbanCardId,
12
    orderedIds: readonly KanbanCardId[],
13
    modifiers: { readonly toggle?: boolean; readonly range?: boolean } = {},
14
  ): void;
15

16
  prune(visibleIds: ReadonlySet<KanbanCardId>): void;
17
}

`KanbanSwimlaneGroupRowRendererOptions`

1
interface KanbanSwimlaneGroupRowRendererOptions {
2
  readonly getProjection: () => KanbanProjection<T> | null;
3
  readonly getConfig: () => ResolvedKanbanConfig<T>;
4
  readonly getLabels: () => KanbanLabels;
5
  readonly onSwimlaneToggle: (swimlaneId: KanbanSwimlaneId) => void
6
}

`KanbanSwimlaneGroupRowRenderer`

Renders projected lane identity rows across the full workflow viewport.

1
class KanbanSwimlaneGroupRowRenderer {
2
  apply(detail: BeforeRowRenderEvent<KanbanGridRow<T>>): void;
3
}

`renderKanbanToggleIcon`

1
export function renderKanbanToggleIcon(h: KanbanTemplateH);

`getCoreFilteredKanbanCardIds`

1
export function getCoreFilteredKanbanCardIds<T extends DataType>(options: {
2
  readonly cards: readonly T[];
3
  readonly idField: ColumnProp;
4
  readonly filterPlugin?: FilterPlugin;
5
  readonly hostColumns: readonly (ColumnGrouping | ColumnRegular)[];
6
}): ReadonlySet<KanbanCardId> | undefined;

`getCoreFilteredKanbanSourceIndexes`

Preserves physical identity for missing and duplicate card ids during core filtering.

1
export function getCoreFilteredKanbanSourceIndexes<T extends DataType>(options: {
2
  readonly cards: readonly T[];
3
  readonly filterPlugin?: FilterPlugin;
4
  readonly hostColumns: readonly (ColumnGrouping | ColumnRegular)[];
5
}): ReadonlySet<number> | undefined;

Kanban

Module Extensions

KanbanContextMenuConfig

ResolveKanbanCardRuleOptions

HTMLRevoGridElementEventMap (Extended from global)

AdditionalData (Extended from @revolist/revogrid)

HTMLRevoGridElement (Extended from global)

Plugin API

KanbanPlugin

Dependencies

BEFORE_KANBAN_CARD_MOVE_EVENT

KANBAN_CARD_MOVE_EVENT

KANBAN_SELECTION_CHANGE_EVENT

KANBAN_COLUMN_ORDER_CHANGE_EVENT

KANBAN_DROP_STATE_CHANGE_EVENT

KANBAN_DIAGNOSTICS_EVENT

KANBAN_CARD_CREATE_REQUEST_EVENT

KANBAN_CARD_OPEN_REQUEST_EVENT

KANBAN_CARD_EDIT_REQUEST_EVENT

KANBAN_CARD_DELETE_REQUEST_EVENT

BEFORE_KANBAN_CARD_CREATE_EVENT

KANBAN_CARD_CREATE_EVENT

BEFORE_KANBAN_CARD_UPDATE_EVENT

KANBAN_CARD_UPDATE_EVENT

BEFORE_KANBAN_CARD_DELETE_EVENT

KANBAN_CARD_DELETE_EVENT

resolveKanbanLabels

DEFAULT_KANBAN_LABELS

resolveKanbanHistoryConfig

isKanbanHistoryConfig

KANBAN_HISTORY_RECORD_EVENT

KanbanHistoryTool

KanbanLabels

KanbanCardRuleResult

KanbanCardRule

KanbanDropRuleContext

KanbanRules

KanbanCardConfig

KanbanFilterConfig

KanbanSelectionConfig

KanbanSwimlaneColumnConfig

KanbanSwimlaneLayout

KanbanContextMenuItemId

KanbanContextMenuItemContext

KanbanContextMenuItemVisibility

KanbanConfig

ResolvedKanbanConfig (Extended from index.ts)

KanbanCardMoveDetail

KanbanBeforeCardMoveDetail (Extended from index.ts)

KanbanSelectionChangeDetail

KanbanColumnOrderChangeDetail

KanbanDropStateChangeDetail

KanbanDiagnosticsDetail

KanbanCardRequestDetail

KanbanMutationReason

KanbanCardCreateDetail

KanbanCardUpdateDetail

KanbanCardDeleteDetail

KanbanMutationResult

KanbanCardId

KanbanColumnProp

KanbanSwimlaneId

KanbanCardLocation

KanbanColumnDefinition

KanbanColumnHeaderRenderContext

KanbanColumnTemplateProp (Extended from index.ts)

KanbanColumnTemplate

KanbanColumnProperties

KanbanSwimlaneDefinition

KanbanDiagnosticCode

KanbanDiagnostic

KanbanProjectedCard

KanbanGridRow (Extended from index.ts)

KanbanProjection

KanbanMoveTarget

KanbanMoveOptions

KanbanCreateOptions

KanbanUpdateOptions

KanbanDeleteOptions (Extended from index.ts)

KanbanField