rowvia 0.2.4 → 0.3.1

package/dist/types/render/headerView.d.ts

@@ -1,5 +1,5 @@
-import type { Column, GridOptions } from '../types';
 import { EventService } from '../core/eventService';
+import type { Column, GridOptions } from '../types';
 export interface HeaderContext {
     options: GridOptions;
     /** UI text lookup (localeText) */

package/dist/types/render/rowComponent.d.ts

@@ -0,0 +1,29 @@
+import type { Column, RowNode } from '../types';
+import type { RowRendererContext } from './rowContext';
+export declare class RowComp {
+    private ctx;
+    private node;
+    private rowHeight;
+    private eLeft;
+    private eCenter;
+    private eRight;
+    private cellComps;
+    private pinned;
+    constructor(ctx: RowRendererContext, node: RowNode, leftColumns: Column[], centerColumns: Column[], rightColumns: Column[], rowHeight: number, _heightVersion: number);
+    isPinned(): boolean;
+    /** marks the row as a sticky group row (rendered in the sticky overlay) */
+    setSticky(sticky: boolean): void;
+    /** hover highlight spans every section of the row */
+    setHovered(hovered: boolean): void;
+    getNode(): RowNode;
+    private createRowElement;
+    private cellColumnIndex;
+    private createCell;
+    private updateCellContent;
+    refreshCells(columns?: Column[], force?: boolean, flash?: boolean): void;
+    appendTo(leftContainer: HTMLElement, centerContainer: HTMLElement, rightContainer: HTMLElement): void;
+    setTop(top: number): void;
+    getCenterElement(): HTMLElement | null;
+    getCellElements(): HTMLElement[];
+    destroy(): void;
+}

package/dist/types/render/rowContext.d.ts

@@ -0,0 +1,39 @@
+import type { RowModel } from '../core/clientSideRowModel';
+import type { EventService } from '../core/eventService';
+import type { Column, GridOptions, RowNode } from '../types';
+export interface RowRendererContext {
+    options: GridOptions;
+    eventService: EventService;
+    rowModel: RowModel;
+    /** UI text lookup (localeText) */
+    t: (key: string) => string;
+    getColumns: () => {
+        left: Column[];
+        center: Column[];
+        right: Column[];
+    };
+    getRowHeight: (node: RowNode) => number;
+    isNodeSelected: (node: RowNode) => boolean;
+    isRowSelectable: (node: RowNode) => boolean;
+    getRowClass: (node: RowNode) => string;
+    getRowStyle: (node: RowNode) => Record<string, any>;
+    onCellClicked: (params: any) => void;
+    onCellDoubleClicked: (params: any) => void;
+    onCellMouseDown: (params: any) => void;
+    onCellContextMenu: (params: any) => void;
+    onRowClicked: (params: any) => void;
+    onRowDoubleClicked: (params: any) => void;
+    onRowGroupClicked?: (node: RowNode) => void;
+    onViewportKeyDown: (event: KeyboardEvent) => void;
+    onViewportScroll?: () => void;
+    getCellText: (column: Column, node: RowNode) => string;
+    renderDetailRow?: (node: RowNode, eRow: HTMLElement) => {
+        eDetail: HTMLElement;
+        height: number;
+    } | null;
+    rowDragEnabled: () => boolean;
+    onRowDragStart?: (node: RowNode, eGui: HTMLElement, event: MouseEvent) => void;
+    getNote?: (rowNodeId: string, colId: string, colDefNote: any, params: any) => string | undefined;
+    onNoteClick?: (rowNodeId: string, colId: string, anchor: HTMLElement) => void;
+    rowNumberOffset?: () => number;
+}

package/dist/types/render/rowRenderer.d.ts

@@ -1,43 +1,8 @@
-import type { Column, GridOptions, RowNode } from '../types';
-import type { RowModel } from '../core/clientSideRowModel';
-import type { EventService } from '../core/eventService';
-import { escapeHtml } from '../core/utils';
-export interface RowRendererContext {
-    options: GridOptions;
-    eventService: EventService;
-    rowModel: RowModel;
-    /** UI text lookup (localeText) */
-    t: (key: string) => string;
-    getColumns: () => {
-        left: Column[];
-        center: Column[];
-        right: Column[];
-    };
-    getRowHeight: (node: RowNode) => number;
-    isNodeSelected: (node: RowNode) => boolean;
-    isRowSelectable: (node: RowNode) => boolean;
-    getRowClass: (node: RowNode) => string;
-    getRowStyle: (node: RowNode) => Record<string, any>;
-    onCellClicked: (params: any) => void;
-    onCellDoubleClicked: (params: any) => void;
-    onCellMouseDown: (params: any) => void;
-    onCellContextMenu: (params: any) => void;
-    onRowClicked: (params: any) => void;
-    onRowDoubleClicked: (params: any) => void;
-    onRowGroupClicked?: (node: RowNode) => void;
-    onViewportKeyDown: (event: KeyboardEvent) => void;
-    onViewportScroll?: () => void;
-    getCellText: (column: Column, node: RowNode) => string;
-    renderDetailRow?: (node: RowNode, eRow: HTMLElement) => {
-        eDetail: HTMLElement;
-        height: number;
-    } | null;
-    rowDragEnabled: () => boolean;
-    onRowDragStart?: (node: RowNode, eGui: HTMLElement, event: MouseEvent) => void;
-    getNote?: (rowNodeId: string, colId: string, colDefNote: any, params: any) => string | undefined;
-    onNoteClick?: (rowNodeId: string, colId: string, anchor: HTMLElement) => void;
-    rowNumberOffset?: () => number;
-}
+import type { Column, RowNode } from '../types';
+import { RowComp } from './rowComponent';
+import type { RowRendererContext } from './rowContext';
+export { escapeHtml } from '../core/utils';
+export type { RowRendererContext } from './rowContext';
 export declare class RowRenderer {
     private ctx;
     private eRoot;
@@ -59,16 +24,15 @@ export declare class RowRenderer {
     private eStickyLeft;
     private eStickyCenter;
     private eStickyRight;
-    private eRangeOverlay;
     private rowComps;
     private stickyComps;
     private hoveredRowId;
     private rowOffsets;
+    private rowIndices;
     private rowInfos;
     private totalHeight;
     private lastScrollTop;
     private lastRange;
-    private firstRendered;
     private heightVersion;
     private scrollFrame;
     constructor(eRoot: HTMLElement, eHeader: HTMLElement, ctx: RowRendererContext);
@@ -84,7 +48,6 @@ export declare class RowRenderer {
     getBody(): HTMLElement;
     getContainer(): HTMLElement;
     getRowComps(): Map<string, RowComp>;
-    setRangeOverlay(eOverlay: HTMLElement | null): void;
     getHeaderElement(): HTMLElement;
     /** recompute row offsets (variable heights) */
     private recomputeOffsets;
@@ -156,39 +119,9 @@ export declare class RowRenderer {
     getRowOffsets(): number[];
     getTotalHeight(): number;
     private findCellFromEvent;
-    private getRowIndexForNode;
     private onClick;
     private onDoubleClick;
     private onMouseDown;
     private onContextMenu;
     destroy(): void;
 }
-declare class RowComp {
-    private ctx;
-    private node;
-    private rowHeight;
-    private heightVersion;
-    private eLeft;
-    private eCenter;
-    private eRight;
-    private cellComps;
-    private pinned;
-    constructor(ctx: RowRendererContext, node: RowNode, leftColumns: Column[], centerColumns: Column[], rightColumns: Column[], rowHeight: number, heightVersion: number);
-    isPinned(): boolean;
-    /** marks the row as a sticky group row (rendered in the sticky overlay) */
-    setSticky(sticky: boolean): void;
-    /** hover highlight spans every section of the row */
-    setHovered(hovered: boolean): void;
-    getNode(): RowNode;
-    private createRowElement;
-    private cellColumnIndex;
-    private createCell;
-    private updateCellContent;
-    refreshCells(columns?: Column[], force?: boolean, flash?: boolean): void;
-    appendTo(leftContainer: HTMLElement, centerContainer: HTMLElement, rightContainer: HTMLElement): void;
-    setTop(top: number): void;
-    getCenterElement(): HTMLElement | null;
-    getCellElements(): HTMLElement[];
-    destroy(): void;
-}
-export { escapeHtml };

package/dist/types/shared/dom.d.ts

@@ -0,0 +1 @@
+export * from '../fields/internal/dom';

package/dist/types/shared/interaction.d.ts

@@ -0,0 +1 @@
+export * from '../fields/internal/interaction';

package/dist/types/shared/lifecycle.d.ts

@@ -0,0 +1 @@
+export * from '../fields/internal/lifecycle';

package/dist/types/shared/markup.d.ts

@@ -0,0 +1,5 @@
+export { escapeHtml as esc } from '../core/utils';
+export declare const icon: (name: string) => string;
+export declare const button: (action: string, label: string, glyph?: string, cls?: string) => string;
+export declare const person: (value: string) => string;
+export declare const selectHtml: (values: [string, string][], value: string, attr?: string) => string;

package/dist/types/shared/state.d.ts

@@ -0,0 +1,5 @@
+/** A borrowed state cell; the owner controls storage and lifetime. */
+export interface StateRef<T> {
+    get(): T;
+    set(value: T): void;
+}

package/dist/types/types.d.ts

@@ -1,3 +1,4 @@
+import type { InteractionOptions, InteractionSource } from './shared/interaction';
 /**
  * rowvia public types — API mirrors ag-grid Community/Enterprise.
  */
@@ -390,7 +391,7 @@ export interface FilterModelItem {
     condition2?: any;
     filterModels?: FilterModelItem[];
 }
-export interface GridApi {
+export interface GridApi extends InteractionSource {
     setRowData(rowData: any[]): void;
     applyTransaction(transaction: RowDataTransaction): RowNodeTransactionResult | null;
     getRowNode(id: string): RowNode | undefined;
@@ -650,7 +651,7 @@ export interface RowDataUpdatedEvent {
     api: GridApi;
 }
 export type GridEventType = 'gridReady' | 'gridSizeChanged' | 'firstDataRendered' | 'modelUpdated' | 'rowDataUpdated' | 'cellValueChanged' | 'cellEditRequest' | 'rowValueChanged' | 'selectionChanged' | 'cellClicked' | 'cellDoubleClicked' | 'cellFocused' | 'rowClicked' | 'rowDoubleClicked' | 'cellEditingStarted' | 'cellEditingStopped' | 'cellKeyDown' | 'sortChanged' | 'filterChanged' | 'columnVisible' | 'columnPinned' | 'columnResized' | 'columnMoved' | 'columnEverythingChanged' | 'columnRowGroupChanged' | 'columnValueChanged' | 'columnPivotModeChanged' | 'displayedColumnsChanged' | 'virtualColumnsChanged' | 'columnHeaderClicked' | 'columnHeaderContextMenu' | 'componentStateChanged' | 'dragStopped' | 'rowDragEnter' | 'rowDragMove' | 'rowDragLeave' | 'rowDragEnd' | 'rowGroupOpened' | 'expandOrCollapseAll' | 'paginationChanged' | 'bodyScroll' | 'bodyScrollEnd' | 'rangeSelectionChanged' | 'rangeSelectionDeleted' | 'cutStart' | 'cutEnd' | 'pasteStart' | 'pasteEnd' | 'fillStart' | 'fillEnd' | 'cellContextMenu' | 'rowEditingStarted' | 'rowEditingStopped' | 'filterModified' | 'filterUiChanged' | 'filterOpened' | 'floatingFilterUiChanged' | 'advancedFilterBuilderVisibleChanged' | 'toolPanelVisibleChanged' | 'toolPanelSizeChanged' | 'sideBarUpdated' | 'chartCreated' | 'chartRangeSelectionChanged' | 'chartOptionsChanged' | 'chartDestroyed' | 'cellFocusCleared' | 'fullWidthCellKeyDown' | 'rowResize?' | 'itemsAdded' | 'itemsRemoved' | 'storeRefreshed' | 'asyncTransactionsFlushed' | 'newColumnsLoaded' | 'rowCountReady' | 'storeUpdated' | 'keyShortcutChangedCell' | 'cellShiftDown?';
-export interface GridOptions {
+export interface GridOptions extends InteractionOptions {
     columnDefs?: ColDef[];
     rowData?: any[];
     defaultColDef?: DefaultColDef;

package/dist/types/work-items/action-surface.d.ts

@@ -0,0 +1,17 @@
+import { Lifecycle } from '../shared/lifecycle';
+import { type InteractionOptions } from '../shared/interaction';
+export interface WorkItemAction {
+    action: string;
+    anchor: HTMLElement;
+    originalEvent: MouseEvent;
+}
+export interface ActionSurfaceOptions extends InteractionOptions {
+    onAction?: (event: WorkItemAction) => void;
+}
+/** Mounts one surface; commands are reported to its owner, never executed here. */
+export declare function createActionSurface(container: HTMLElement, className: string, markup: string, options: ActionSurfaceOptions): {
+    element: HTMLDivElement;
+    lifecycle: Lifecycle;
+    onInteraction: (listener: (event: import("..").ComponentInteraction) => void) => import("../shared/lifecycle").Dispose;
+    destroy(): void;
+};

package/dist/types/work-items/detail/detail-comments.d.ts

@@ -0,0 +1,44 @@
+import type { WorkItem } from '../../contracts/work-item';
+import type { FieldServices, FieldOption } from '../../fields/types';
+export type DetailComment = Exclude<WorkItem['comments'][number], string> & {
+    authorId?: string;
+    replyTo?: string;
+};
+export interface DetailCommentSave {
+    action: 'create' | 'edit' | 'reply';
+    id?: string;
+    replyTo?: string;
+    html: string;
+    content: string;
+}
+export interface DetailCommentsPermissions {
+    create?: boolean;
+    reply?: boolean | ((comment: DetailComment) => boolean);
+    edit?: boolean | ((comment: DetailComment) => boolean);
+}
+export interface DetailCommentsOptions {
+    comments?: Array<string | DetailComment>;
+    data?: Array<string | DetailComment>;
+    author: string | {
+        id: string;
+        display: string;
+    };
+    permissions?: DetailCommentsPermissions;
+    people?: FieldOption[];
+    services?: Pick<FieldServices, 'searchOptions'>;
+    onSave?: (command: DetailCommentSave, signal: AbortSignal) => WorkItem['comments'] | Promise<WorkItem['comments']>;
+    onPublish?: (payload: DetailCommentSave, signal: AbortSignal) => boolean | Promise<boolean>;
+    onEdit?: (id: string, payload: DetailCommentSave, signal: AbortSignal) => boolean | Promise<boolean>;
+    hasMore?: boolean;
+    onLoadMore?: (signal: AbortSignal) => void | Promise<void>;
+    renderActions?: (container: HTMLElement, comment: DetailComment) => void | (() => void);
+    renderAttachments?: (container: HTMLElement, comment: DetailComment) => void | (() => void);
+}
+export declare function createDetailComments(initial: DetailCommentsOptions): {
+    element: HTMLElement;
+    composer: HTMLDivElement;
+    decorateTab: (surface: HTMLElement) => void;
+    update: (patch: Partial<Pick<DetailCommentsOptions, "comments" | "data" | "permissions" | "hasMore">>) => void;
+    deactivate: () => void;
+    destroy: () => void;
+};

package/dist/types/work-items/detail/detail-header.d.ts

@@ -0,0 +1,23 @@
+import { type InteractionOptions } from '../../shared/interaction';
+export interface DetailStage {
+    id: string;
+    label: string;
+    state?: 'done' | 'active' | 'pending';
+}
+export interface DetailHeaderConfig extends InteractionOptions {
+    tags?: string[];
+    signals?: {
+        label: string;
+        checked?: boolean;
+    }[];
+    stages?: DetailStage[];
+    activeStage?: string;
+    owner?: string;
+    onAction?: (action: string) => void;
+}
+/** Mountable process header with semantic action and interaction subscriptions. */
+export declare function createWorkItemDetailHeader(config?: DetailHeaderConfig): {
+    element: HTMLElement;
+    onInteraction: (listener: (event: import("../..").ComponentInteraction) => void) => import("../../shared/lifecycle").Dispose;
+    destroy(): void;
+};

package/dist/types/work-items/detail/detail-history.d.ts

@@ -0,0 +1,38 @@
+import type { WorkItem } from '../../contracts/work-item';
+import { type HistoryQuery, type HistoryEntry, type HistoryModule } from './history-model';
+export interface DetailHistoryPage {
+    rows: HistoryEntry[];
+    total?: number;
+    matching?: number;
+    nextCursor?: string | null;
+    previousCursor?: string | null;
+}
+export interface DetailHistoryQuery extends HistoryQuery {
+    cursor?: string;
+}
+export interface DetailHistoryOptions {
+    records?: WorkItem['history'];
+    rows?: HistoryEntry[];
+    query?: Partial<DetailHistoryQuery>;
+    nextCursor?: string | null;
+    previousCursor?: string | null;
+    actor?: string;
+    nodeFlow?: boolean;
+    mode?: 'server' | 'local';
+    page?: DetailHistoryPage;
+    modules?: HistoryModule[];
+    operators?: Array<{
+        id: string;
+        label: string;
+    }>;
+    onQuery?: (query: DetailHistoryQuery, signal: AbortSignal) => DetailHistoryPage | void | Promise<DetailHistoryPage | void>;
+    onLoadMore?: (cursor: string, query: DetailHistoryQuery, signal: AbortSignal) => DetailHistoryPage | void | Promise<DetailHistoryPage | void>;
+    renderDetail?: (container: HTMLElement, entry: HistoryEntry) => void | (() => void);
+}
+export declare function createDetailHistory(initial: DetailHistoryOptions): {
+    element: HTMLElement;
+    refresh: (loadMore?: boolean) => void;
+    deactivate: () => void;
+    update: (patch: Partial<Pick<DetailHistoryOptions, "records" | "rows" | "page" | "query" | "nextCursor" | "previousCursor" | "modules" | "operators">>) => void;
+    destroy: () => void;
+};

package/dist/types/work-items/detail/history-model.d.ts

@@ -0,0 +1,48 @@
+import type { WorkItem } from '../../contracts/work-item';
+export type HistoryEntry = Exclude<WorkItem['history'][number], string>;
+export interface HistoryModule {
+    key: string;
+    label: string;
+}
+export interface HistoryQuery {
+    keyword: string;
+    keywordFilter: boolean;
+    operatorKinds: Set<string>;
+    operators: Set<string>;
+    modules: Set<string>;
+    start: string;
+    end: string;
+    page: number;
+}
+export declare const historyModules: HistoryModule[];
+export declare function normalizeHistory(item: Pick<WorkItem, 'history'>, actor: string): HistoryEntry[];
+/** The log endpoint already supplies localized display content; origin_content is not HTML. */
+export declare function adaptOperationRecords(records: Array<{
+    id: string;
+    operator?: {
+        user_key: string;
+        name: string;
+    };
+    operator_type: number;
+    op_record_type_key: string;
+    op_record_type_name: string;
+    content: string;
+    created_at: number;
+}>): HistoryEntry[];
+export declare function queryHistory(logs: HistoryEntry[], query: HistoryQuery): {
+    rows: {
+        id?: string;
+        actor: string;
+        actorId?: string;
+        actorKind?: "user" | "computed" | "automation" | "system";
+        module: string;
+        moduleKey?: string;
+        detail: string;
+        createdAt: string;
+    }[];
+    total: number;
+    matching: number;
+    filteredTotal: number;
+    page: number;
+    pageCount: number;
+};

package/dist/types/work-items/fields/control-base.d.ts

@@ -0,0 +1,17 @@
+import type { ControlContext, ControlPage, FieldControl } from '../../contracts/work-item';
+/**
+ * Shared shell for all field controls. Controls provide the content for a
+ * state; the shell owns page/state metadata and keeps host styling consistent.
+ */
+export declare const BaseFieldControl: {
+    page(context: ControlContext): ControlPage;
+    render(context: ControlContext, content: HTMLElement): HTMLElement;
+};
+/**
+ * Feishu field boxes come in three geometries: single-line text, multi-line
+ * text and tag/select style rows. Hosts and the focus shell label every box
+ * with this kind so display and edit states can share one set of metrics.
+ */
+export type FieldBoxKind = 'text' | 'rich' | 'select';
+export declare function fieldBoxKind(control: Pick<FieldControl, 'id'>): FieldBoxKind;
+export { autosizeTextarea } from '../../fields/internal/textarea';

package/dist/types/{pages/work-items → work-items/fields}/focus-editor.d.ts

@@ -1,3 +1,3 @@
-import type { ControlContext, ControlEditor, FieldControl } from './controls';
+import type { ControlContext, ControlEditor, FieldControl } from '../../contracts/work-item';
 /** One focus boundary for every registered editor, including custom controls. */
 export declare function focusEditor(control: FieldControl, context: ControlContext, editor: ControlEditor): ControlEditor;

package/dist/types/work-items/fields/registry.d.ts

@@ -0,0 +1,5 @@
+import type { FieldControl, ControlRegistry } from '../../contracts/work-item';
+export { BaseFieldControl, fieldBoxKind, autosizeTextarea } from './control-base';
+export { sanitizeRichText } from '../../fields/rich-control';
+export type { ControlContext, ControlEditor, ControlMode, ControlPage, ControlSurface, FieldControl } from '../../contracts/work-item';
+export declare function createControlRegistry(custom?: FieldControl[]): ControlRegistry;

package/dist/types/work-items/index.d.ts

@@ -0,0 +1,27 @@
+export type * from '../contracts/work-item';
+export { createWorkflowDetail } from './workflow-detail';
+export type * from './workflow-detail-types';
+export { createDetailComments } from './detail/detail-comments';
+export type { DetailComment, DetailCommentSave, DetailCommentsPermissions, DetailCommentsOptions } from './detail/detail-comments';
+export { createDetailHistory } from './detail/detail-history';
+export type { DetailHistoryPage, DetailHistoryQuery, DetailHistoryOptions } from './detail/detail-history';
+export { historyModules, normalizeHistory, queryHistory, adaptOperationRecords } from './detail/history-model';
+export type { HistoryEntry, HistoryModule, HistoryQuery } from './detail/history-model';
+export type { FormCondition, FormConditionOp, FormScope, FormSurfaceContext } from '../forms/form-conditions';
+export { emptyView, matches } from './model';
+export { createWorkItemTabs } from './tabs';
+export type { WorkItemTabsOptions } from './tabs';
+export { createWorkItemToolbar } from './toolbar';
+export type { WorkItemToolbarOptions, WorkItemRuleCounts } from './toolbar';
+export { createWorkItemSelectionBar } from './selection-bar';
+export type { ActionSurfaceOptions, WorkItemAction } from './action-surface';
+export { createWorkItemTable } from './table/table';
+export { createColumns as createWorkItemColumns } from './table/columns';
+export type { ColumnsDeps as WorkItemColumnsOptions } from './table/columns';
+export { createColumnPanels as createWorkItemColumnPanels } from './table/column-panels';
+export { createHeaderDecorator as createWorkItemHeaderDecorator } from './table/headers';
+export { createRulePanels as createWorkItemRulePanels } from './views/rule-panels';
+export { createWorkItemDetailHeader } from './detail/detail-header';
+export type { DetailHeaderConfig, DetailStage } from './detail/detail-header';
+export { createWorkItemLayers } from './layers';
+export type { WorkItemLayersOptions, WorkItemLayerKind } from './layers';

package/dist/types/work-items/layers.d.ts

@@ -0,0 +1,19 @@
+import { type InteractionOptions } from '../shared/interaction';
+export type WorkItemLayerKind = 'popup' | 'overlay';
+export interface WorkItemLayersOptions extends InteractionOptions {
+    /** A host can validate or save an editor before calling closePopup/closeOverlay. */
+    onCloseRequest?: (kind: WorkItemLayerKind) => void;
+    onOpen?: (kind: WorkItemLayerKind, element: HTMLElement) => void;
+    onClose?: (kind: WorkItemLayerKind) => void;
+}
+/** Scoped layer DOM and resource ownership; persistence and validation stay with the caller. */
+export declare function createWorkItemLayers(container: HTMLElement, options?: WorkItemLayersOptions): {
+    element: HTMLDivElement;
+    onInteraction: (listener: (event: import("..").ComponentInteraction) => void) => import("../shared/lifecycle").Dispose;
+    closePopup: () => void;
+    closeOverlay: () => void;
+    showPopup(anchor: HTMLElement, title: string, content: string, width?: number, className?: string): HTMLElement;
+    showOverlay(content: string | HTMLElement, className?: string): HTMLElement;
+    toast(message: string): void;
+    destroy(): void;
+};

package/dist/types/work-items/model.d.ts

@@ -0,0 +1,10 @@
+import type { FieldConfig, Rule, SavedView, ViewState, WorkItem } from '../contracts/work-item';
+export type { ColorRule, Field, Rule, SavedView, ViewState, WorkItem } from '../contracts/work-item';
+export declare const emptyView: () => ViewState;
+export declare function matches(item: WorkItem, rules: Rule[]): boolean;
+export declare function loadData(key: string, initialItems?: WorkItem[]): {
+    items: WorkItem[];
+    views: SavedView[];
+    drafts: WorkItem[];
+    customFields: FieldConfig[];
+};

package/dist/types/work-items/selection-bar.d.ts

@@ -0,0 +1,7 @@
+import { type ActionSurfaceOptions } from './action-surface';
+export declare function createWorkItemSelectionBar(container: HTMLElement, options?: ActionSurfaceOptions): {
+    element: HTMLDivElement;
+    onInteraction: (listener: (event: import("..").ComponentInteraction) => void) => import("../shared/lifecycle").Dispose;
+    destroy: () => void;
+    setCount(count: number): void;
+};

package/dist/types/work-items/style-scope.d.ts

@@ -0,0 +1 @@
+export declare function acquireWorkItemScope(container: HTMLElement): () => void;

package/dist/types/work-items/table/column-panels.d.ts

@@ -0,0 +1,39 @@
+import { createGrid } from "../../createGrid";
+import { type ColDef } from '../../types';
+import type { FieldConfig } from '../../contracts/work-item';
+import { createControlRegistry } from "../fields/registry";
+import { loadData, type Field, type ViewState } from "../model";
+/** Services and state accessors the column panels borrow from the page host. */
+export interface ColumnPanelDeps {
+    config: {
+        container: HTMLElement;
+        fields: FieldConfig[];
+    };
+    data: ReturnType<typeof loadData>;
+    fields: [string, string][];
+    fieldConfig: (key: string) => FieldConfig | undefined;
+    options: Record<string, string[]>;
+    controls: ReturnType<typeof createControlRegistry>;
+    instance: () => ReturnType<typeof createGrid>;
+    view: () => ViewState;
+    $: <T extends HTMLElement = HTMLElement>(selector: string, root?: ParentNode) => T;
+    showPopup: (anchor: HTMLElement, title: string, content: string, width?: number, className?: string) => HTMLElement;
+    closePopup: (saveChanges?: boolean) => void;
+    applyView: () => void;
+    save: () => void;
+    resizeGrid: () => void;
+    decorateHeaders: () => void;
+    columnDefs: () => ColDef[];
+    textDialog: (title: string, value: string, submit: (value: string) => void) => void;
+    rulePanel: (kind: string, anchor: HTMLElement) => void;
+}
+/** Field picker, column display settings, insert-field and header context menus. */
+export declare function createColumnPanels(deps: ColumnPanelDeps): {
+    fieldPicker: (anchor: HTMLElement, onSelect: (field: Field) => void, settings?: {
+        available?: (field: Field) => boolean;
+        onCreate?: () => void;
+    }) => void;
+    showColumns: (anchor: HTMLElement) => void;
+    showInsertField: (anchor: HTMLElement, field: string, after: boolean) => void;
+    showColumnMenu: (anchor: HTMLElement, field: string) => void;
+};

package/dist/types/work-items/table/columns.d.ts

@@ -0,0 +1,28 @@
+import type { CellRendererParams, ColDef } from '../../types';
+import type { ColorRule, FieldConfig, ViewState, WorkItem } from '../../contracts/work-item';
+import { createControlRegistry, type ControlContext } from "../fields/registry";
+import type { StateRef } from '../../shared/state';
+/** Services and state accessors the cell renderer and column defs borrow from the page host. */
+export interface ColumnsDeps {
+    config: {
+        fields: FieldConfig[];
+        allowCustomFields?: boolean;
+    };
+    controls: ReturnType<typeof createControlRegistry>;
+    fieldConfig: (key: string) => FieldConfig | undefined;
+    options: Record<string, string[]>;
+    view: () => ViewState;
+    $: <T extends HTMLElement = HTMLElement>(selector: string, root?: ParentNode) => T;
+    tag: (value: string, field: string) => string;
+    activateCell: (anchor: HTMLElement, field: string, item: WorkItem, rowIndex: number) => void;
+    controlContext: (def: FieldConfig, item: WorkItem, surface: ControlContext["surface"]) => ControlContext;
+    openDetail: (item: WorkItem, tab?: string) => void;
+    colorRuleMatches: (item: WorkItem, rule: ColorRule) => boolean;
+    customColumns: () => ColDef[];
+    detailClickTimer: StateRef<number>;
+}
+/** Grid cell renderer and column definitions, extracted from the page factory. */
+export declare function createColumns(deps: ColumnsDeps): {
+    cell: (params: CellRendererParams) => HTMLElement | string;
+    columnDefs: () => ColDef[];
+};

package/dist/types/work-items/table/headers.d.ts

@@ -0,0 +1,10 @@
+import type { FieldConfig, ViewState } from '../../contracts/work-item';
+export interface HeaderActions {
+    root: HTMLElement;
+    view: () => ViewState;
+    fieldConfig: (key: string) => FieldConfig | undefined;
+    showInsertField: (anchor: HTMLElement, field: string, after: boolean) => void;
+    showColumnMenu: (anchor: HTMLElement, field: string) => void;
+    applyView: () => void;
+}
+export declare function createHeaderDecorator(actions: HeaderActions): () => void;

package/dist/types/work-items/table/table.d.ts

@@ -0,0 +1,10 @@
+import type { GridOptions } from '../../types';
+import type { InteractionOptions } from '../../shared/interaction';
+/** A standalone editable table. Its owner supplies fields, data and commands. */
+export declare function createWorkItemTable(container: HTMLElement, options: GridOptions & InteractionOptions): {
+    onInteraction: (listener: (event: import("../..").ComponentInteraction) => void) => import("../../shared/lifecycle").Dispose;
+    destroy(): void;
+    api: import("../..").GridApi;
+    columnApi: import("../..").ColumnApi;
+    grid: import("../..").Grid;
+};

package/dist/types/work-items/tabs.d.ts

@@ -0,0 +1,14 @@
+import { type ActionSurfaceOptions } from './action-surface';
+export interface WorkItemTabsOptions extends ActionSurfaceOptions {
+    tabs: readonly string[];
+    value?: string;
+    canCreate?: boolean;
+    onChange?: (value: string) => void;
+}
+export declare function createWorkItemTabs(container: HTMLElement, options: WorkItemTabsOptions): {
+    element: HTMLDivElement;
+    onInteraction: (listener: (event: import("..").ComponentInteraction) => void) => import("../shared/lifecycle").Dispose;
+    setValue: (next: string) => void;
+    getValue: () => string;
+    destroy: () => void;
+};

package/dist/types/work-items/toolbar.d.ts

@@ -0,0 +1,11 @@
+import { type ActionSurfaceOptions } from './action-surface';
+export interface WorkItemToolbarOptions extends ActionSurfaceOptions {
+    onSearch?: (query: string, filter: boolean) => void;
+}
+export type WorkItemRuleCounts = Record<'filter' | 'sort' | 'group' | 'color', number>;
+export declare function createWorkItemToolbar(container: HTMLElement, options?: WorkItemToolbarOptions): {
+    element: HTMLDivElement;
+    onInteraction: (listener: (event: import("..").ComponentInteraction) => void) => import("../shared/lifecycle").Dispose;
+    destroy: () => void;
+    setRuleCounts(counts: WorkItemRuleCounts): void;
+};