@orangelogic/design-system 2.142.0 → 2.143.0

package/library/components/typography.js

@@ -1,6 +1,6 @@
 import "../chunks/lib-cortex-element.CVMmyPMC.js";
 import "../chunks/component.styles.CRO4Odto.js";
-import { C as a } from "../chunks/typography.DJC_UXgs.js";
+import { C as a } from "../chunks/typography.IqHbnd3C.js";
 import "../chunks/custom-element.L4WJXn1j.js";
 import "../chunks/lit-element.jLBm65_O.js";
 export {

package/library/components/video.js

@@ -1,14 +1,14 @@
 import { _ as kd, a as Sa, b as Be, c as Je } from "../chunks/inheritsLoose.BuSn_CvZ.js";
 import { c as ps, a as Bn } from "../chunks/_commonjsHelpers.DQNKXVTB.js";
 import { r as Sb } from "../chunks/___vite-browser-external_commonjs-proxy.C2tf3HsQ.js";
-import { C as Cb } from "../chunks/image.B3vsXGrN.js";
+import { C as Cb } from "../chunks/image.C2acLx6g.js";
 import Mb from "./resize-observer.js";
 import { r as Db, R as Pb, a as Rp, b as Lb } from "../chunks/resizable-component.styles.CAfXABBc.js";
 import { c as Rb } from "../chunks/component.styles.CRO4Odto.js";
 import { b as Ib } from "../chunks/browser.BHOCIF_A.js";
 import { c as Ob } from "../chunks/custom-element.L4WJXn1j.js";
-import { L as kb } from "../chunks/i18n.DeUAP8n2.js";
-import { w as Ki } from "../chunks/watch.CThbualB.js";
+import { L as kb } from "../chunks/i18n.C4wPyPTR.js";
+import { w as Ki } from "../chunks/watch.CkGTlwIo.js";
 import { i as Bb, x as Qc } from "../chunks/lit-element.jLBm65_O.js";
 import { n as Ri } from "../chunks/lib-cortex-element.CVMmyPMC.js";
 import { r as yn } from "../chunks/state.CSDxrqLd.js";

package/library/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orangelogic/design-system",
   "type": "module",
-  "version": "2.142.0",
+  "version": "2.143.0",
   "license": "UNLICENSED",
   "types": "library/types.d.ts",
   "scripts": {

package/library/packages/atoms/src/components/header/header.d.ts

@@ -71,7 +71,7 @@ export default class CxHeader extends CortexElement {
     addSlotElement(): void;
     handleHeadingChange(): void;
     private handleCopyButtonClick;
-    renderHeading(content: TemplateResult): TemplateResult;
+    renderHeading(): TemplateResult;
     render(): TemplateResult;
 }
 declare global {

package/library/packages/events/src/cx-board-change.d.ts

@@ -0,0 +1,12 @@
+export type CxBoardChangeEvent = CustomEvent<{
+    id: string;
+    isMultiDrag?: boolean;
+    items: string[];
+    newIndex?: number;
+    type: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-board-change': CxBoardChangeEvent;
+    }
+}

package/library/packages/events/src/cx-board-selected-change.d.ts

@@ -0,0 +1,10 @@
+export type CxBoardSelectedChangeEvent = CustomEvent<{
+    id: string;
+    items: string[];
+    type?: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-board-selected-change': CxBoardSelectedChangeEvent;
+    }
+}

package/library/packages/events/src/cx-font-picker-change.d.ts

@@ -0,0 +1,9 @@
+export type CxFontPickerChangeEvent = CustomEvent<{
+    family: string;
+    style: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-font-picker-change': CxFontPickerChangeEvent;
+    }
+}

package/library/packages/events/src/cx-multi-select-change.d.ts

@@ -0,0 +1,11 @@
+import { BoardItem } from '../../types/src/board';
+
+export type CxMultiSelectChangeEvent = CustomEvent<{
+    id: string;
+    items: BoardItem[];
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-multi-select-change': CxMultiSelectChangeEvent;
+    }
+}

package/library/packages/events/src/cx-multi-select-configure.d.ts

@@ -0,0 +1,8 @@
+export type CxMultiSelectConfigureEvent = CustomEvent<{
+    id: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-multi-select-configure': CxMultiSelectConfigureEvent;
+    }
+}

package/library/packages/events/src/cx-table-column-editor-apply.d.ts

@@ -0,0 +1,8 @@
+export type CxTableColumnEditorApplyEvent = CustomEvent<{
+    visibleFields: string[];
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-table-column-editor-apply': CxTableColumnEditorApplyEvent;
+    }
+}

package/library/packages/events/src/cx-table-column-editor-cancel.d.ts

@@ -0,0 +1,6 @@
+export type CxTableColumnEditorCancelEvent = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-table-column-editor-cancel': CxTableColumnEditorCancelEvent;
+    }
+}

package/library/packages/events/src/cx-table-column-visibility-change.d.ts

@@ -0,0 +1,9 @@
+export type CxTableColumnVisibilityChangeEvent = CustomEvent<{
+    field: string;
+    visible: boolean;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-table-column-visibility-change': CxTableColumnVisibilityChangeEvent;
+    }
+}

package/library/packages/events/src/cx-table-columns-change.d.ts

@@ -0,0 +1,8 @@
+export type CxTableColumnsChangeEvent = CustomEvent<{
+    visibleFields: string[];
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-table-columns-change': CxTableColumnsChangeEvent;
+    }
+}

package/library/packages/events/src/cx-table-edit-columns.d.ts

@@ -0,0 +1,8 @@
+export type CxTableEditColumnsEvent = CustomEvent<{
+    field: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-table-edit-columns': CxTableEditColumnsEvent;
+    }
+}

package/library/packages/events/src/cx-table-header-menu-close.d.ts

@@ -0,0 +1,6 @@
+export type CxTableHeaderMenuCloseEvent = CustomEvent<Record<PropertyKey, never>>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-table-header-menu-close': CxTableHeaderMenuCloseEvent;
+    }
+}

package/library/packages/events/src/cx-table-header-menu-select.d.ts

@@ -0,0 +1,11 @@
+import { TableHeaderMenuAction } from '../../types/src/table';
+
+export type CxTableHeaderMenuSelectEvent = CustomEvent<{
+    action: TableHeaderMenuAction;
+    field: string;
+}>;
+declare global {
+    interface GlobalEventHandlersEventMap {
+        'cx-table-header-menu-select': CxTableHeaderMenuSelectEvent;
+    }
+}

package/library/packages/events/src/events.d.ts

@@ -23,6 +23,8 @@ export * from './cx-bento-range-change';
 export * from './cx-bento-resize';
 export * from './cx-bicolor-picker-change';
 export * from './cx-blur';
+export * from './cx-board-change';
+export * from './cx-board-selected-change';
 export * from './cx-book-reader-event';
 export * from './cx-border-input-group-change';
 export * from './cx-cancel';
@@ -83,6 +85,7 @@ export * from './cx-focus';
 export * from './cx-folder-select-children-loaded';
 export * from './cx-folder-select-search-term-change';
 export * from './cx-folder-select-selection-seeded';
+export * from './cx-font-picker-change';
 export * from './cx-gallery-chunk-request';
 export * from './cx-gallery-config-save';
 export * from './cx-gallery-item-click';
@@ -122,6 +125,8 @@ export * from './cx-marker-create';
 export * from './cx-marker-delete';
 export * from './cx-masonry-select';
 export * from './cx-mount-request-asset';
+export * from './cx-multi-select-change';
+export * from './cx-multi-select-configure';
 export * from './cx-mutation';
 export * from './cx-open-cache-location';
 export * from './cx-open-drive';
@@ -189,10 +194,17 @@ export * from './cx-swatch-add';
 export * from './cx-tab-hide';
 export * from './cx-tab-show';
 export * from './cx-table-advanced-search-click';
+export * from './cx-table-column-editor-apply';
+export * from './cx-table-column-editor-cancel';
+export * from './cx-table-column-visibility-change';
+export * from './cx-table-columns-change';
 export * from './cx-table-data-load';
 export * from './cx-table-dropdown-filter-change';
+export * from './cx-table-edit-columns';
 export * from './cx-table-export';
 export * from './cx-table-group-by-change';
+export * from './cx-table-header-menu-close';
+export * from './cx-table-header-menu-select';
 export * from './cx-table-row-action-click';
 export * from './cx-table-save-search-select';
 export * from './cx-table-select-all-change';

package/library/packages/hybrid/table-core/src/table/components/index.d.ts

@@ -1,3 +1,5 @@
+export { default as CxTableColumnEditor } from './table-column-editor/table-column-editor';
 export { default as CxTableFooter } from './table-footer/table-footer';
+export { default as CxTableHeaderMenu } from './table-header-menu/table-header-menu';
 export { default as CxTableRowActions } from './table-row-actions/table-row-actions';
 export { default as CxTableToolbar } from './table-toolbar/table-toolbar';

package/library/packages/hybrid/table-core/src/table/components/table-column-editor/table-column-editor.d.ts

@@ -0,0 +1,45 @@
+import { default as CxButton } from '../../../../../../atoms/src/components/button/button.ts';
+import { default as CxDialog } from '../../../../../../atoms/src/components/dialog/dialog.ts';
+import { default as CortexElement } from '../../../../../../base/src/cortex-element.ts';
+import { default as CxMultiSelect } from '../../../../../../molecules/src/multi-select/multi-select.ts';
+import { TableColumnEditorEntry } from '../../../../../../types/src/table-column-editor';
+import { CSSResultGroup } from 'lit';
+
+/**
+ * @summary Bulk "Edit columns" editor for `cx-table`. Opens a modal dialog containing a
+ * `cx-multi-select`: left list is available (hidden) columns, right list is visible columns,
+ * reorderable via drag. Frozen columns are shown locked and pinned first in the visible list.
+ *
+ * @event {{ visibleFields: string[] }} cx-table-column-editor-apply - Emitted when the user confirms a new visible column set/order.
+ * @event cx-table-column-editor-cancel - Emitted when the user dismisses the editor without applying.
+ */
+export default class CxTableColumnEditor extends CortexElement {
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-button': typeof CxButton;
+        'cx-dialog': typeof CxDialog;
+        'cx-multi-select': typeof CxMultiSelect;
+    };
+    private readonly localize;
+    private readonly dialogEl;
+    /** Whether the editor dialog is open. */
+    open: boolean;
+    /** Snapshot of columns (in current render order) to edit. Set by `cx-table`. */
+    entries: TableColumnEditorEntry[];
+    private firstColumnData;
+    private secondColumnData;
+    /** Current order of the visible ("selected") board, including frozen fields. */
+    private visibleFields;
+    private get canApply();
+    handleEntriesChange(): void;
+    private handleMultiSelectChange;
+    private handleApply;
+    private handleCancel;
+    private handleDialogRequestClose;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-table-column-editor': CxTableColumnEditor;
+    }
+}

package/library/packages/hybrid/table-core/src/table/components/table-column-editor/table-column-editor.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/hybrid/table-core/src/table/components/table-header-menu/table-header-menu.d.ts

@@ -0,0 +1,55 @@
+import { default as CxIcon } from '../../../../../../atoms/src/components/icon/icon.ts';
+import { default as CxMenu } from '../../../../../../atoms/src/components/menu/menu.ts';
+import { default as CxMenuItem } from '../../../../../../atoms/src/components/menu-item/menu-item.ts';
+import { default as CxPopup } from '../../../../../../atoms/src/components/popup/popup.ts';
+import { default as CortexElement } from '../../../../../../base/src/cortex-element.ts';
+import { CSSResultGroup } from 'lit';
+
+/**
+ * @summary Right-click context menu for `cx-table` column headers, offering "Edit columns" (extension point) and
+ * "Hide column" actions.
+ *
+ * @description Anchored to the cursor position via a `VirtualElement`. Dismisses on outside click, a second
+ * right-click outside the menu, or `Escape`.
+ *
+ * @event {{ action: TableHeaderMenuAction, field: string }} cx-table-header-menu-select - Emitted when a menu item is selected.
+ * @event cx-table-header-menu-close - Emitted when the menu should be closed (outside interaction or Escape).
+ */
+export default class CxTableHeaderMenu extends CortexElement {
+    static readonly styles: CSSResultGroup;
+    static readonly dependencies: {
+        'cx-icon': typeof CxIcon;
+        'cx-menu': typeof CxMenu;
+        'cx-menu-item': typeof CxMenuItem;
+        'cx-popup': typeof CxPopup;
+    };
+    private readonly localize;
+    private readonly virtualAnchor;
+    private readonly firstMenuItem;
+    /** Whether the menu is open. */
+    open: boolean;
+    /** The cursor's x position (viewport coordinates) the menu is anchored to. */
+    pointX: number;
+    /** The cursor's y position (viewport coordinates) the menu is anchored to. */
+    pointY: number;
+    /** The field of the column the menu was opened for. */
+    field: string;
+    /** Disables the "Hide column" item, e.g. when only one visible data column remains. */
+    hideDisabled: boolean;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    handleOpenChange(): void;
+    private handlePopupOpened;
+    private removeDocumentListeners;
+    private handleDocumentMouseDown;
+    private handleDocumentKeyDown;
+    private emitClose;
+    private handleMenuSelect;
+    render(): import('lit').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-table-header-menu': CxTableHeaderMenu;
+    }
+}

package/library/packages/hybrid/table-core/src/table/components/table-header-menu/table-header-menu.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/hybrid/table-core/src/table/table.d.ts

@@ -14,7 +14,7 @@ import { DateFilterCompareFormat, HoverMenuOptions, HttpMethod, PaginationPlacem
 import { SavedSearchItem, TableDropdownFilterData, TableGroupByOption } from '../../../../types/src/table-toolbar';
 import { CSSResultGroup, TemplateResult } from 'lit';
 import { RowComponent, TabulatorFull as Tabulator } from '../tabulator-tables';
-import { CxTableFooter, CxTableRowActions, CxTableToolbar } from './components';
+import { CxTableColumnEditor, CxTableFooter, CxTableHeaderMenu, CxTableRowActions, CxTableToolbar } from './components';
 
 /**
  * @summary Tables are used to display data in a structured format.
@@ -71,6 +71,8 @@ import { CxTableFooter, CxTableRowActions, CxTableToolbar } from './components';
  * @event {{ url: string, format: string, rowCount: number }} cx-table-data-load - Emitted when data is successfully loaded from dataUrl.
  * @event {{ url: string, error: unknown }} cx-table-data-load-error - Emitted when fetching or parsing data from dataUrl fails.
  * @event {{ invalidCellCount: number, invalidCells: ICellComponent[] }} cx-table-validation-change - Emitted when the set of cells failing column `validator` rules changes (edit, load validation, or programmatic validate).
+ * @event {{ field: string, visible: boolean }} cx-table-column-visibility-change - Emitted after a column's visibility changes via the header right-click "Hide column" action.
+ * @event {{ field: string }} cx-table-edit-columns - Emitted when "Edit columns" is chosen from the header right-click menu. Extension point for a future manage-columns panel; no built-in panel is shown.
  */
 export default class CxTable extends CortexElement {
     #private;
@@ -87,7 +89,9 @@ export default class CxTable extends CortexElement {
         'cx-select': typeof CxSelect;
         'cx-space': typeof CxSpace;
         'cx-spinner': typeof CxSpinner;
+        'cx-table-column-editor': typeof CxTableColumnEditor;
         'cx-table-footer': typeof CxTableFooter;
+        'cx-table-header-menu': typeof CxTableHeaderMenu;
         'cx-table-row-actions': typeof CxTableRowActions;
         'cx-table-toolbar': typeof CxTableToolbar;
         'cx-tooltip': typeof CxTooltip;
@@ -213,6 +217,11 @@ export default class CxTable extends CortexElement {
      * The columnDefaults option allows you to set default configs for all columns in the table.
      */
     columnDefaults: Partial<ColumnDefinition>;
+    /**
+     * Enables the right-click context menu on column headers, offering "Edit columns" and "Hide column" actions.
+     * Disabled by default.
+     */
+    headerContextMenu: boolean;
     /**
      * Whether to display a search box
      */
@@ -798,6 +807,20 @@ export default class CxTable extends CortexElement {
     private dataUrlRequestId;
     /** True when facets are available — either from facet-config or from an AJAX response. Controls toolbar visibility. */
     hasFacets: boolean;
+    /** Whether the column-header right-click context menu is open. */
+    private headerMenuOpen;
+    /** The field of the column the header context menu was opened for. */
+    private headerMenuField;
+    /** The cursor's x position (viewport coordinates) the header context menu is anchored to. */
+    private headerMenuPointX;
+    /** The cursor's y position (viewport coordinates) the header context menu is anchored to. */
+    private headerMenuPointY;
+    /** Whether "Hide column" is disabled because hiding it would leave no visible data columns. */
+    private headerMenuHideDisabled;
+    /** Whether the bulk "Edit columns" editor dialog is open. */
+    private columnEditorOpen;
+    /** Snapshot of columns (in current render order) handed to the editor when it opens. */
+    private columnEditorEntries;
     get initialized(): boolean | undefined;
     get searchValue(): string;
     get isBottomPlacement(): boolean;
@@ -899,6 +922,23 @@ export default class CxTable extends CortexElement {
     private handleTabulatorAjaxResponse;
     private renderToolbar;
     private renderPaginationFooter;
+    /** Opens the column-header right-click context menu, anchored to the cursor position. */
+    private handleHeaderContextMenu;
+    private handleHeaderMenuSelect;
+    private handleHeaderMenuClose;
+    private handleColumnEditorApply;
+    private handleColumnEditorCancel;
+    /** Counts visible data columns (columns with a `field`) to decide whether "Hide column" should be disabled. */
+    private getVisibleDataColumnCount;
+    /** Builds the "Edit columns" editor model from current data columns, in current render order. */
+    private getColumnEditorModel;
+    /**
+     * Applies the "Edit columns" editor result: shows/hides non-frozen data columns to match
+     * `orderedVisibleFields`, reorders them to match, then emits the public change event. Frozen
+     * columns are never hidden or moved — they stay pinned, matching the engine's own
+     * MoveColumns guard against dragging frozen columns.
+     */
+    applyColumnEditor(orderedVisibleFields: string[]): void;
     render(): TemplateResult;
 }
 declare global {

package/library/packages/molecules/src/font-picker/font-picker.d.ts

@@ -0,0 +1,74 @@
+import { default as CxDivider } from '../../../atoms/src/components/divider/divider.ts';
+import { default as CxGrid } from '../../../atoms/src/components/grid/grid.ts';
+import { default as CxGridItem } from '../../../atoms/src/components/grid-item/grid-item.ts';
+import { default as CxMenuLabel } from '../../../atoms/src/components/menu-label/menu-label.ts';
+import { default as CxOption } from '../../../atoms/src/components/option/option.ts';
+import { default as CxSelect } from '../../../atoms/src/components/select/select.ts';
+import { default as CxSpace } from '../../../atoms/src/components/space/space.ts';
+import { default as CxTypography } from '../../../atoms/src/components/typography/typography.ts';
+import { default as CortexElement } from '../../../base/src/cortex-element.ts';
+import { FontPickerLayout, FontTypeface, FontTypefaceGroup } from '../../../types/src/font-picker';
+import { CSSResultGroup, TemplateResult } from 'lit';
+
+/**
+ * @summary A picker that allows selecting a typeface and its font family variant.
+ *
+ * @event {{ family: string; style: string }} cx-font-picker-change - Emitted when the selected typeface or font family changes.
+ *
+ * @csspart base - The component's base wrapper.
+ * @csspart family - The typeface select.
+ * @csspart style - The font-family select.
+ *
+ */
+export default class CxFontPicker extends CortexElement {
+    static readonly styles: CSSResultGroup;
+    private readonly localize;
+    static readonly dependencies: {
+        'cx-divider': typeof CxDivider;
+        'cx-grid': typeof CxGrid;
+        'cx-grid-item': typeof CxGridItem;
+        'cx-menu-label': typeof CxMenuLabel;
+        'cx-option': typeof CxOption;
+        'cx-select': typeof CxSelect;
+        'cx-space': typeof CxSpace;
+        'cx-typography': typeof CxTypography;
+    };
+    /** The list of available typefaces, each containing font family variants. */
+    fontTypefaces: FontTypeface[];
+    /** The list of typeface groups, each with a label and typefaces. Takes precedence over fontTypefaces when non-empty. */
+    fontTypefaceGroups: FontTypefaceGroup[];
+    /** The selected typeface value. */
+    familyValue: string;
+    /** The selected font family value. Empty string means no family selected. */
+    styleValue: string;
+    /** Controls how the two selects are arranged. */
+    layout: FontPickerLayout;
+    /** Label text for the typeface select. */
+    labelFamily: string;
+    /** Label text for the font family select. */
+    labelStyle: string;
+    /** Marks both selects as required for form validation. */
+    required: boolean;
+    /**
+     * Single normalized representation of the input: an ungrouped `fontTypefaces`
+     * list becomes one unlabeled group, so the template has a single render path.
+     * Grouped input (`fontTypefaceGroups`) takes precedence when provided.
+     */
+    private get typefaceGroups();
+    private get allTypefaces();
+    private get selectedTypeface();
+    private get availableFamilies();
+    /** Whether the selected typeface exposes any style/variant options. */
+    private get hasStyleOptions();
+    private handleFamilyChange;
+    private handleStyleChange;
+    private renderTypefaceOptions;
+    private renderFamilySelect;
+    private renderStyleSelect;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'cx-font-picker': CxFontPicker;
+    }
+}

package/library/packages/molecules/src/font-picker/font-picker.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('lit').CSSResult;
+export default _default;

package/library/packages/molecules/src/index.d.ts

@@ -20,6 +20,7 @@ export { default as CxFacetDateRange } from './faceted-filter/components/facet-d
 export { default as CxFacetedFilter } from './faceted-filter/faceted-filter';
 export { default as CxFacetedFilterFacet } from './faceted-filter/components/facet/facet';
 export { default as CxFolderSelect } from './folder-select/folder-select';
+export { default as CxFontPicker } from './font-picker/font-picker';
 export { default as CxGalleryItem } from './gallery-item/gallery-item';
 export { default as CxGraphView } from './graph-view/graph-view';
 export { default as CxIconPicker } from './icon-picker/icon-picker';

package/library/packages/molecules/src/multi-select/components/board/board.d.ts

@@ -7,18 +7,6 @@ import { BoardItem } from '../../../../../types/src/board';
 import { default as Sortable } from 'sortablejs';
 import { default as CxBoardListItem } from '../board-list-item/board-list-item';
 
-export type CxBoardChangeEvent = CustomEvent<Record<PropertyKey, unknown>>;
-export type CxBoardSelectedChangeEvent = CustomEvent<Record<PropertyKey, unknown>>;
-export type CxBoardItemAddedEvent = CustomEvent<Record<PropertyKey, unknown>>;
-export type CxBoardItemRemovedEvent = CustomEvent<Record<PropertyKey, unknown>>;
-declare global {
-    interface GlobalEventHandlersEventMap {
-        'cx-board-change': CxBoardChangeEvent;
-        'cx-board-item-added': CxBoardItemAddedEvent;
-        'cx-board-item-removed': CxBoardItemRemovedEvent;
-        'cx-board-selected-change': CxBoardSelectedChangeEvent;
-    }
-}
 /**
  * @summary Board is a list of items that can be reordered by dragging and dropping them.
  *
@@ -80,12 +68,17 @@ export default class CxBoard extends CortexElement {
     get selectedCount(): number;
     get isAllSelected(): boolean;
     get isPartiallySelected(): boolean;
+    /**
+     * Rows counted toward "select all" (excludes synthetic group headers, disabled, and
+     * ignored-type items). `ignoreTypes` only gates this bulk select-all set — an ignored-type
+     * item can still be selected individually via click, keyboard, or shift-range.
+     */
+    get selectableItems(): BoardItem[];
     constructor();
     private resetSelectedItems;
     /** Handles the update of items in the board. */
     private handleUpdateEvent;
     private handleSelectedChange;
-    private handleItemConfigure;
     private handleListScroll;
     private handleSearchChange;
     private handleSearchClear;
@@ -98,12 +91,44 @@ export default class CxBoard extends CortexElement {
     handleDefaultSelect(item: CxBoardListItem): void;
     handleShiftSelect(item: CxBoardListItem): void;
     handleSelect(evt: MouseEvent): void;
+    /**
+     * Whether a row is a real, individually-selectable item (not a synthetic group header, not
+     * disabled). Deliberately excludes the `ignoreTypes` check — an ignored type only opts an
+     * item out of the "select all" bulk set (see `selectableItems`), not out of individual
+     * click/keyboard/shift selection.
+     */
+    private isSelectableItem;
+    /**
+     * Selects only `boardItem`, deselecting all others (or deselects everything if it was already
+     * the sole selection) — the same single-item selection behavior as a plain (non-modifier,
+     * non-checkbox) click, reused by the row's `Enter`/`Space` keyboard handler.
+     */
+    private selectSingleItem;
+    private handleItemKeydown;
     handleStart(evt: Sortable.SortableEvent): void;
     handleUpdate(evt: Sortable.SortableEvent): void;
+    /**
+     * Keeps disabled (`readonly`) rows fixed relative to each other when other rows are reordered.
+     * `readonly` on `draggable` only stops a disabled row from being dragged itself — Sortable can
+     * still drop an enabled row before/between disabled rows, which would indirectly move the
+     * disabled item and break the not-movable contract (and the frozen-column prefix). Only allow a
+     * drop next to a readonly row when it lands immediately after the last readonly row in a
+     * contiguous readonly block; reject every other position touching a readonly row.
+     */
+    handleMove(evt: Sortable.MoveEvent): boolean | undefined;
     deselectAll(force?: boolean): void;
     selectAll(): void;
     handleSelectAll(): void;
-    onAllChanged(): void;
+    private handleSelectAllKeydown;
+    /** Index in `this.items` immediately after the last real (non-header) visible row. */
+    private indexAfterLastVisibleRealItem;
+    /**
+     * Maps a drop position expressed as an index into the (filtered/grouped) visible list to an
+     * insertion index within the full `this.items` array. Group headers are skipped forward to the
+     * nearest real item; a drop at or past the end resolves to immediately after the last visible
+     * real item.
+     */
+    private resolveRealInsertIndex;
     private initSortable;
     /** Initializes the sortable functionality for the list element. */
     runFirstUpdated(): void;

package/library/packages/molecules/src/multi-select/components/board-list-item/board-list-item.d.ts

@@ -5,16 +5,6 @@ import { default as CxTooltip } from '../../../../../atoms/src/components/toolti
 import { default as CortexElement } from '../../../../../base/src/cortex-element.ts';
 import { TemplateResult } from 'lit';
 
-export type CxMultiSelectConfigureEvent = CustomEvent<Record<PropertyKey, string>>;
-export type CxBoardItemLabelClickEvent = CustomEvent<Record<PropertyKey, string>>;
-export type CxBoardItemCheckboxClickEvent = CustomEvent<Record<PropertyKey, string>>;
-declare global {
-    interface GlobalEventHandlersEventMap {
-        'cx-board-item-checkbox-click': CxBoardItemCheckboxClickEvent;
-        'cx-board-item-label-click': CxBoardItemLabelClickEvent;
-        'cx-multi-select-configure': CxMultiSelectConfigureEvent;
-    }
-}
 export default class CxBoardListItem extends CortexElement {
     static readonly styles: import('lit').CSSResult[];
     static readonly dependencies: {
@@ -23,6 +13,7 @@ export default class CxBoardListItem extends CortexElement {
         'cx-line-clamp': typeof CxLineClamp;
         'cx-tooltip': typeof CxTooltip;
     };
+    private readonly localize;
     configButton: CxIconButton;
     textElement: HTMLElement;
     tooltipElement: CxTooltip;