@adaptabletools/adaptable 23.0.5-canary.1 → 23.0.6

package/index.css

@@ -1,4 +1,4 @@
-/*! tailwindcss v4.3.1 | MIT License | https://tailwindcss.com */
+/*! tailwindcss v4.3.2 | MIT License | https://tailwindcss.com */
 @layer properties;
 @layer adaptable.reset, adaptable.components, adaptable.utilities, adaptable.theming;
 @property --tw-animation-delay {
@@ -1556,6 +1556,9 @@
   .twa\:border-\[var\(--ab-cmp-wizard-type-selection-card__selected-border\)\] {
     border-color: var(--ab-cmp-wizard-type-selection-card__selected-border);
   }
+  .twa\:border-accent {
+    border-color: var(--ab-color-accent);
+  }
   .twa\:border-border {
     border-color: var(--ab-color-border);
   }
@@ -1567,6 +1570,9 @@
       border-color: color-mix(in oklab, var(--ab-color-border) 60%, transparent);
     }
   }
+  .twa\:border-destructive {
+    border-color: var(--ab-color-destructive);
+  }
   .twa\:border-foreground\/10 {
     border-color: var(--ab-color-foreground);
   }
@@ -1864,6 +1870,9 @@
   .twa\:py-3 {
     padding-block: calc(var(--ab-base-space) * 3);
   }
+  .twa\:py-\[2px\] {
+    padding-block: 2px;
+  }
   .twa\:\!pt-0 {
     padding-top: 0 !important;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "23.0.5-canary.1",
+  "version": "23.0.6",
   "description": "Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableOptions/AdaptableOptions.d.ts

@@ -13,6 +13,7 @@ import { DashboardOptions } from './DashboardOptions';
 import { ToolPanelOptions } from './ToolPanelOptions';
 import { DataChangeHistoryOptions } from './DataChangeHistoryOptions';
 import { SettingsPanelOptions } from './SettingsPanelOptions';
+import { WizardOptions } from './WizardOptions';
 import { FlashingCellOptions } from './FlashingCellOptions';
 import { AlertOptions } from './AlertOptions';
 import { ExpressionOptions } from './ExpressionOptions';
@@ -228,6 +229,14 @@ export interface AdaptableOptions<TData = any, TContext = Record<string, any>> {
      * @noCodeContainer
      */
     settingsPanelOptions?: SettingsPanelOptions;
+    /**
+     * Options for managing Wizards (and other action popups such as Bulk Update,
+     * Smart Edit and Cell Summary) — controls their `popupType`, initial
+     * `position` and `size` independently of the Settings Panel.
+     *
+     * @noCodeContainer
+     */
+    wizardOptions?: WizardOptions;
     /**
      * Options related to state hydration / dehydration - allows users to intercept state persistence and state loading and change default behaviour of saving to local storage
      */

package/src/AdaptableOptions/DefaultAdaptableOptions.d.ts

@@ -1,3 +1,20 @@
 import { AdaptableOptions } from './AdaptableOptions';
+/**
+ * Merges the user-supplied `adaptableOptions` with `DefaultAdaptableOptions`,
+ * filling in any missing values at any nesting depth.
+ *
+ * Behaviour:
+ * - User-supplied leaf values always win.
+ * - Nested plain-object blocks (e.g. `editOptions.plusMinusOptions`,
+ *   `fdc3Options.actionColumnDefaultConfiguration.rowScope`) are recursively
+ *   merged so the user can override individual leaves without losing other
+ *   default leaves in the same block.
+ * - Arrays, functions, primitives and class instances are NOT element-merged —
+ *   the user's value replaces the default entirely.
+ * - The caller's input object is never mutated.
+ *
+ * Adding a new options block or nested sub-block only requires updating
+ * `DefaultAdaptableOptions` above — this function does not need to be touched.
+ */
 export declare function applyDefaultAdaptableOptions(adaptableOptions: AdaptableOptions): AdaptableOptions;
 export declare const getDefaultAdaptableOptions: () => AdaptableOptions<any, Record<string, any>>;

package/src/AdaptableOptions/DefaultAdaptableOptions.js

@@ -4,6 +4,7 @@ import { ACCESS_LEVEL_FULL, EMPTY_STRING, EMPTY_ARRAY, DEFAULT_DATE_FORMAT_PATTE
 import { SystemAlertPredicateIds, SystemBadgeStylePredicateIds, SystemFilterPredicateIds, SystemFlashingCellPredicateIds, SystemFormatColumnPredicateIds, } from '../AdaptableState/Common/AdaptablePredicate';
 import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
 import { addUuidsToInitialState } from '../Utilities/Helpers/AdaptableHelper';
+import { defaultsDeep } from '../Utilities/Extensions/ObjectExtensions';
 const DefaultAdaptableOptions = {
     adaptableId: GeneralConstants.ADAPTABLE_ID,
     adaptableStateKey: undefined,
@@ -275,6 +276,11 @@ const DefaultAdaptableOptions = {
         customSettingsPanels: undefined,
         gridInfoTabs: ['Grid Options', 'Grid Summary', 'Grid State'],
     },
+    wizardOptions: {
+        popupType: undefined,
+        position: undefined,
+        size: undefined,
+    },
     stateOptions: {
         debounceStateDelay: 400,
         applyState: (state) => state,
@@ -331,54 +337,9 @@ const DefaultAdaptableOptions = {
     },
 };
 export function applyDefaultAdaptableOptions(adaptableOptions) {
-    const adaptableOptsWithDefaults = Object.assign({}, DefaultAdaptableOptions, adaptableOptions);
+    const adaptableOptsWithDefaults = defaultsDeep({ ...adaptableOptions }, DefaultAdaptableOptions);
     adaptableOptsWithDefaults.adaptableStateKey =
         adaptableOptsWithDefaults.adaptableStateKey ?? adaptableOptsWithDefaults.adaptableId;
-    adaptableOptsWithDefaults.actionColumnOptions = Object.assign({}, DefaultAdaptableOptions.actionColumnOptions, adaptableOptions.actionColumnOptions);
-    adaptableOptsWithDefaults.rowFormOptions = Object.assign({}, DefaultAdaptableOptions.rowFormOptions, adaptableOptions.rowFormOptions);
-    adaptableOptsWithDefaults.alertOptions = Object.assign({}, DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
-    adaptableOptsWithDefaults.calendarOptions = Object.assign({}, DefaultAdaptableOptions.calendarOptions, adaptableOptions.calendarOptions);
-    adaptableOptsWithDefaults.cellSummaryOptions = Object.assign({}, DefaultAdaptableOptions.cellSummaryOptions, adaptableOptions.cellSummaryOptions);
-    adaptableOptsWithDefaults.chartingOptions = Object.assign({}, DefaultAdaptableOptions.chartingOptions, adaptableOptions.chartingOptions);
-    adaptableOptsWithDefaults.chartingOptions.externalChartingOptions = Object.assign({}, DefaultAdaptableOptions.chartingOptions.externalChartingOptions, adaptableOptsWithDefaults.chartingOptions.externalChartingOptions);
-    adaptableOptsWithDefaults.columnOptions = Object.assign({}, DefaultAdaptableOptions.columnOptions, adaptableOptions.columnOptions);
-    adaptableOptsWithDefaults.filterOptions = Object.assign({}, DefaultAdaptableOptions.filterOptions, adaptableOptions.filterOptions);
-    adaptableOptsWithDefaults.filterOptions.columnFilterOptions = Object.assign({}, DefaultAdaptableOptions.filterOptions.columnFilterOptions, adaptableOptsWithDefaults.filterOptions.columnFilterOptions);
-    adaptableOptsWithDefaults.filterOptions.gridFilterOptions = Object.assign({}, DefaultAdaptableOptions.filterOptions.gridFilterOptions, adaptableOptsWithDefaults.filterOptions.gridFilterOptions);
-    adaptableOptsWithDefaults.columnMenuOptions = Object.assign({}, DefaultAdaptableOptions.columnMenuOptions, adaptableOptions.columnMenuOptions);
-    adaptableOptsWithDefaults.commentOptions = Object.assign({}, DefaultAdaptableOptions.commentOptions, adaptableOptions.commentOptions);
-    adaptableOptsWithDefaults.containerOptions = Object.assign({}, DefaultAdaptableOptions.containerOptions, adaptableOptions.containerOptions);
-    adaptableOptsWithDefaults.contextMenuOptions = Object.assign({}, DefaultAdaptableOptions.contextMenuOptions, adaptableOptions.contextMenuOptions);
-    adaptableOptsWithDefaults.customSortOptions = Object.assign({}, DefaultAdaptableOptions.customSortOptions, adaptableOptions.customSortOptions);
-    adaptableOptsWithDefaults.dashboardOptions = Object.assign({}, DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);
-    adaptableOptsWithDefaults.dataImportOptions = Object.assign({}, DefaultAdaptableOptions.dataImportOptions, adaptableOptions.dataImportOptions);
-    adaptableOptsWithDefaults.dataChangeHistoryOptions = Object.assign({}, DefaultAdaptableOptions.dataChangeHistoryOptions, adaptableOptions.dataChangeHistoryOptions);
-    adaptableOptsWithDefaults.dataSetOptions = Object.assign({}, DefaultAdaptableOptions.dataSetOptions, adaptableOptions.dataSetOptions);
-    adaptableOptsWithDefaults.editOptions = Object.assign({}, DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
-    adaptableOptsWithDefaults.editOptions.plusMinusOptions = Object.assign({}, DefaultAdaptableOptions.editOptions.plusMinusOptions, adaptableOptsWithDefaults.editOptions.plusMinusOptions);
-    adaptableOptsWithDefaults.editOptions.smartEditOptions = Object.assign({}, DefaultAdaptableOptions.editOptions.smartEditOptions, adaptableOptsWithDefaults.editOptions.smartEditOptions);
-    adaptableOptsWithDefaults.entitlementOptions = Object.assign({}, DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
-    adaptableOptsWithDefaults.exportOptions = Object.assign({}, DefaultAdaptableOptions.exportOptions, adaptableOptions.exportOptions);
-    adaptableOptsWithDefaults.expressionOptions = Object.assign({}, DefaultAdaptableOptions.expressionOptions, adaptableOptions.expressionOptions);
-    adaptableOptsWithDefaults.fdc3Options = Object.assign({}, DefaultAdaptableOptions.fdc3Options, adaptableOptions.fdc3Options);
-    adaptableOptsWithDefaults.fdc3Options.actionColumnDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions.fdc3Options.actionColumnDefaultConfiguration, adaptableOptsWithDefaults.fdc3Options.actionColumnDefaultConfiguration);
-    adaptableOptsWithDefaults.fdc3Options.uiControlsDefaultConfiguration = Object.assign({}, DefaultAdaptableOptions.fdc3Options.uiControlsDefaultConfiguration, adaptableOptsWithDefaults.fdc3Options.uiControlsDefaultConfiguration);
-    adaptableOptsWithDefaults.flashingCellOptions = Object.assign({}, DefaultAdaptableOptions.flashingCellOptions, adaptableOptions.flashingCellOptions);
-    adaptableOptsWithDefaults.formatColumnOptions = Object.assign({}, DefaultAdaptableOptions.formatColumnOptions, adaptableOptions.formatColumnOptions);
-    adaptableOptsWithDefaults.layoutOptions = Object.assign({}, DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
-    adaptableOptsWithDefaults.layoutOptions.layoutTagOptions = Object.assign({}, DefaultAdaptableOptions.layoutOptions.layoutTagOptions, adaptableOptsWithDefaults.layoutOptions.layoutTagOptions);
-    adaptableOptsWithDefaults.layoutOptions.layoutViewOptions = Object.assign({}, DefaultAdaptableOptions.layoutOptions.layoutViewOptions, adaptableOptsWithDefaults.layoutOptions.layoutViewOptions);
-    adaptableOptsWithDefaults.noteOptions = Object.assign({}, DefaultAdaptableOptions.noteOptions, adaptableOptions.noteOptions);
-    adaptableOptsWithDefaults.notificationsOptions = Object.assign({}, DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
-    adaptableOptsWithDefaults.predicateOptions = Object.assign({}, DefaultAdaptableOptions.predicateOptions, adaptableOptsWithDefaults.predicateOptions);
-    adaptableOptsWithDefaults.quickSearchOptions = Object.assign({}, DefaultAdaptableOptions.quickSearchOptions, adaptableOptions.quickSearchOptions);
-    adaptableOptsWithDefaults.settingsPanelOptions = Object.assign({}, DefaultAdaptableOptions.settingsPanelOptions, adaptableOptions.settingsPanelOptions);
-    adaptableOptsWithDefaults.stateOptions = Object.assign({}, DefaultAdaptableOptions.stateOptions, adaptableOptions.stateOptions);
-    adaptableOptsWithDefaults.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
-    adaptableOptsWithDefaults.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
-    adaptableOptsWithDefaults.userInterfaceOptions = Object.assign({}, DefaultAdaptableOptions.userInterfaceOptions, adaptableOptions.userInterfaceOptions);
-    adaptableOptsWithDefaults.userInterfaceOptions.loadingScreenOptions = Object.assign({}, DefaultAdaptableOptions.userInterfaceOptions.loadingScreenOptions, adaptableOptsWithDefaults.userInterfaceOptions.loadingScreenOptions);
-    adaptableOptsWithDefaults.userInterfaceOptions.dateInputOptions = Object.assign({}, DefaultAdaptableOptions.userInterfaceOptions.dateInputOptions, adaptableOptsWithDefaults.userInterfaceOptions.dateInputOptions);
     const { initialState } = adaptableOptsWithDefaults;
     adaptableOptsWithDefaults.initialState = addUuidsToInitialState(initialState);
     return adaptableOptsWithDefaults;

package/src/AdaptableOptions/EditOptions.d.ts

@@ -149,13 +149,21 @@ export interface CellEditableContext<TData = any> extends BaseContext {
  */
 export interface PlusMinusOptions {
     /**
-     * Key to increase cell value for nudges (if not overriden in Plus Minus Rule)
+     * Key to increase cell value for nudges (if not overriden in Plus Minus Rule/Nudge).
+     *
+     * Can be a single key (e.g. `'+'`) or a keyboard shortcut combination that uses
+     * `+` as the glue between parts (e.g. `'shift+Enter'`, `'ctrl+ArrowUp'`).
+     * Supported modifiers are `ctrl`, `cmd`, `alt` and `shift`.
      *
      * @defaultValue '+'
      */
     incrementKey?: string;
     /**
-     * Key to decrease cell value for nudges (if not overriden in Plus Minus Rule)
+     * Key to decrease cell value for nudges (if not overriden in Plus Minus Rule/Nudge).
+     *
+     * Can be a single key (e.g. `'-'`) or a keyboard shortcut combination that uses
+     * `+` as the glue between parts (e.g. `'shift+Backspace'`, `'ctrl+ArrowDown'`).
+     * Supported modifiers are `ctrl`, `cmd`, `alt` and `shift`.
      *
      * @defaultValue '-'
      */

package/src/AdaptableOptions/SettingsPanelOptions.d.ts

@@ -2,6 +2,7 @@ import { AdaptableFrameworkComponent, AdaptableIcon } from '../../types';
 import { AdaptableSettingsPanel } from '../AdaptableState/Common/Types';
 import { BaseContext } from '../AdaptableState/Common/BaseContext';
 import { CustomRenderContext } from '../agGrid/AdaptableFrameworkComponent';
+import { WindowPosition, WindowSize } from '../AdaptableState/Common/Window';
 /**
  * Options for managing the AdapTable Settings Panel
  */
@@ -44,13 +45,13 @@ export interface SettingsPanelOptions {
      *
      * @defaultValue Middle of Screen
      */
-    position?: SettingsPanelPosition;
+    position?: WindowPosition;
     /**
      * Initial size (in pixels) of Settings Panel (requires `popupType` to be `'window'`)
      *
      * @defaultValue Computed based on size of screen
      */
-    size?: SettingsPanelSize;
+    size?: WindowSize;
     /**
      * How the Settings Panel is rendered: `'modal'` (centred and unmovable and resizable) or `'window'` (supports size, position, drag and resize)
      *
@@ -68,32 +69,6 @@ export interface SettingsPanelOptions {
      */
     gridInfoTabs?: GridInfoTabs;
 }
-/**
- * Pixel offset of Settings Panel's top-left corner from top-left of the viewport
- */
-export interface SettingsPanelPosition {
-    /**
-     * Distance from the left edge of the viewport, in pixels.
-     */
-    x: number;
-    /**
-     * Distance from the top edge of the viewport, in pixels.
-     */
-    y: number;
-}
-/**
- * Initial dimensions (in pixels) of the Settings Panel
- */
-export interface SettingsPanelSize {
-    /**
-     * Width of the Settings Panel, in pixels.
-     */
-    width: number;
-    /**
-     * Height of the Settings Panel, in pixels.
-     */
-    height: number;
-}
 /**
  * A labelled group of Settings Panel navigation entries.
  */

package/src/AdaptableOptions/WizardOptions.d.ts

@@ -0,0 +1,26 @@
+import { WindowPosition, WindowSize } from '../AdaptableState/Common/Window';
+import { PopupType } from './SettingsPanelOptions';
+/**
+ * Options for managing AdapTable Wizards
+ */
+export interface WizardOptions {
+    /**
+     * How wizards are rendered: `'modal'` (centred & unmovable) or `'window'` (supports size, position, drag, resize)
+     *
+     * @defaultValue inherits from `settingsPanelOptions.popupType`
+     */
+    popupType?: PopupType;
+    /**
+     * Initial position of wizard — pixel offset of top-left corner from top-left of viewport (requires `popupType`: `'window'`)
+     *
+     * @defaultValue Middle of Screen
+     */
+    position?: WindowPosition;
+    /**
+     * Initial size (in pixels) of wizard (requires `popupType`: `'window'`)
+     * `'window'`).
+     *
+     * @defaultValue Computed default sized for wizards
+     */
+    size?: WindowSize;
+}

package/src/AdaptableOptions/WizardOptions.js

@@ -0,0 +1 @@
+export {};

package/src/AdaptableState/Common/CustomWindowConfig.d.ts

@@ -1,5 +1,6 @@
 import { AdaptableSystemIconName } from '../../types';
 import { CustomRenderContext, AdaptableFrameworkComponent } from '../../agGrid/AdaptableFrameworkComponent';
+import { WindowPosition, WindowSize } from './Window';
 /**
  * Config used to open a Custom Window
  */
@@ -37,17 +38,4 @@ export interface CustomWindowConfig {
      */
     position?: WindowPosition;
 }
-/**
- * Defines size of a Custom Window
- */
-export interface WindowSize {
-    width: number;
-    height: number;
-}
-/**
- * Defines position of a Custom Window
- */
-export interface WindowPosition {
-    x: number;
-    y: number;
-}
+export type { WindowPosition, WindowSize } from './Window';

package/src/AdaptableState/Common/Window.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Generic window-shaped types used wherever AdapTable needs a position and/or
+ * size in pixels (Settings Panel, Wizards, Custom Windows, etc.).
+ *
+ * Co-located in `AdaptableState/Common` so any options block can pull in the
+ * same shape without re-declaring it.
+ */
+/**
+ * Pixel offset of a window's top-left corner from the top-left of the viewport.
+ */
+export interface WindowPosition {
+    /**
+     * Distance from the left edge of the viewport, in pixels.
+     */
+    x: number;
+    /**
+     * Distance from the top edge of the viewport, in pixels.
+     */
+    y: number;
+}
+/**
+ * Initial dimensions (in pixels) of a window.
+ */
+export interface WindowSize {
+    /**
+     * Width of the window, in pixels.
+     */
+    width: number;
+    /**
+     * Height of the window, in pixels.
+     */
+    height: number;
+}

package/src/AdaptableState/Common/Window.js

@@ -0,0 +1 @@
+export {};

package/src/AdaptableState/InitialState.d.ts

@@ -77,7 +77,8 @@ export interface InitialState {
     Note?: NoteState;
     /**
      * Plus Minus module: nudge rules. Optional `IncrementKey` / `DecrementKey` on each nudge
-     * use `KeyboardEvent.key`; when omitted, `AdaptableOptions.plusMinusOptions` applies, then `+` / `-`.
+     * accept either a single key or a keyboard shortcut combination (e.g. `shift+Enter`); when
+     * omitted, `AdaptableOptions.plusMinusOptions` applies, then `+` / `-`.
      */
     PlusMinus?: PlusMinusState;
     /**

package/src/AdaptableState/PlusMinusState.d.ts

@@ -32,11 +32,21 @@ export interface PlusMinusNudge extends SuspendableObject {
      */
     Rule?: AdaptableBooleanQuery;
     /**
-     * Optional keyboard `key` that increases cell values for this nudge only (overrides global incrementKey)
+     * Optional keyboard key that increases cell values for this nudge only (overrides the
+     * global `incrementKey` in `plusMinusOptions`).
+     *
+     * Can be a single key (e.g. `'+'`) or a keyboard shortcut combination that uses `+` as the glue
+     * between parts (e.g. `'shift+Enter'`, `'ctrl+ArrowUp'`). Supported modifiers are `ctrl`, `cmd`,
+     * `alt` and `shift`.
      */
     IncrementKey?: string;
     /**
-     * Optional keyboard `key` that decreases cell values for this nudge only (overrides global decrementKey)
+     * Optional keyboard key that decreases cell values for this nudge only (overrides the
+     * global `decrementKey` in `plusMinusOptions`).
+     *
+     * Can be a single key (e.g. `'-'`) or a keyboard shortcut combination that uses `+` as the glue
+     * between parts (e.g. `'shift+Backspace'`, `'ctrl+ArrowDown'`). Supported modifiers are `ctrl`,
+     * `cmd`, `alt` and `shift`.
      */
     DecrementKey?: string;
 }

package/src/Strategy/PlusMinusModule.js

@@ -11,7 +11,7 @@ import { MovePlusMinus } from '../View/PlusMinus/MovePlusMinus';
 import { PlusMinusWizard } from '../View/PlusMinus/Wizard/PlusMinusWizard';
 import { errorOnce } from '../agGrid/AdaptableLogger';
 import NumberExtensions from '../Utilities/Extensions/NumberExtensions';
-import { buildPlusMinusTriggerKeyLookup, plusMinusKeyCouldTrigger, plusMinusKeyMatches, resolvePlusMinusTriggerKeysForNudge, } from '../Utilities/Helpers/PlusMinusHelper';
+import { buildPlusMinusTriggerKeyLookup, plusMinusEventMatchesTrigger, plusMinusKeyCouldTrigger, resolvePlusMinusTriggerKeysForNudge, } from '../Utilities/Helpers/PlusMinusHelper';
 export class PlusMinusModule extends AdaptableModuleBase {
     shouldHandleKeyDown;
     adaptable;
@@ -116,11 +116,11 @@ export class PlusMinusModule extends AdaptableModuleBase {
         }
         const decrementMatches = allActive.filter((nudge) => {
             const { decrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, pmOpts);
-            return plusMinusKeyMatches(keyEventString, decrementKey);
+            return plusMinusEventMatchesTrigger(keyEvent, decrementKey);
         });
         const incrementMatches = allActive.filter((nudge) => {
             const { incrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, pmOpts);
-            return plusMinusKeyMatches(keyEventString, incrementKey);
+            return plusMinusEventMatchesTrigger(keyEvent, incrementKey);
         });
         let side;
         let plusMinusNudges;
@@ -138,6 +138,8 @@ export class PlusMinusModule extends AdaptableModuleBase {
         const isPlusMinusApplicable = this.applyPlusMinus(plusMinusNudges, this.api.gridApi.getSelectedCellInfo().gridCells, side);
         if (isPlusMinusApplicable) {
             keyEvent.preventDefault();
+            keyEvent.stopImmediatePropagation?.();
+            keyEvent.stopPropagation?.();
         }
     }
     applyPlusMinus(plusMinusNudges, cellsToUpdate, direction) {

package/src/Utilities/Extensions/ObjectExtensions.d.ts

@@ -56,4 +56,20 @@ export declare function merge(target: any, ...sources: any[]): any;
  * Drop-in replacement for lodash/mergeWith.
  */
 export declare function mergeWith<T extends object>(target: T, ...args: any[]): T;
+/**
+ * Recursively fills in missing properties on `target` from one or more
+ * `sources` (defaults). For each key:
+ *
+ * - if the target value is `undefined`, it is replaced with a fresh clone of
+ *   the source value;
+ * - if both the target and source values are plain objects, the merge recurses
+ *   into them (the target's nested object is shallow-copied first, so the
+ *   caller's input is never mutated);
+ * - otherwise the target value wins as-is (arrays, functions, primitives, class
+ *   instances etc. are NOT element-merged — the user's value replaces the
+ *   default entirely).
+ *
+ * Drop-in replacement for lodash/defaultsDeep.
+ */
+export declare function defaultsDeep<T extends object>(target: T, ...sources: any[]): T;
 export {};

package/src/Utilities/Extensions/ObjectExtensions.js

@@ -269,3 +269,44 @@ export function mergeWith(target, ...args) {
     }
     return target;
 }
+export function defaultsDeep(target, ...sources) {
+    for (const source of sources) {
+        _baseDefaultsDeep(target, source);
+    }
+    return target;
+}
+function _baseDefaultsDeep(target, defaults) {
+    if (defaults == null) {
+        return target;
+    }
+    const keys = Object.keys(defaults);
+    for (const key of keys) {
+        const defaultValue = defaults[key];
+        const targetValue = target[key];
+        if (targetValue === undefined) {
+            target[key] = _cloneDefaultValue(defaultValue);
+        }
+        else if (isPlainObject(defaultValue) && isPlainObject(targetValue)) {
+            const childCopy = { ...targetValue };
+            _baseDefaultsDeep(childCopy, defaultValue);
+            target[key] = childCopy;
+        }
+    }
+    return target;
+}
+function _cloneDefaultValue(value) {
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(_cloneDefaultValue);
+    }
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const k of Object.keys(value)) {
+            out[k] = _cloneDefaultValue(value[k]);
+        }
+        return out;
+    }
+    return value;
+}

package/src/Utilities/Helpers/PlusMinusHelper.d.ts

@@ -1,5 +1,16 @@
 import type { EditOptions, PlusMinusOptions } from '../../AdaptableOptions/EditOptions';
 import type { PlusMinusNudge } from '../../AdaptableState/PlusMinusState';
+/**
+ * Minimal shape required to match a key press against a Plus/Minus trigger.
+ * Compatible with the native `KeyboardEvent`.
+ */
+export type PlusMinusKeyEvent = {
+    key: string;
+    metaKey?: boolean;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+};
 /**
  * Resolve increment/decrement trigger strings for a single nudge.
  * Per-nudge fields win; otherwise {@link PlusMinusOptions}; otherwise `+` / `-`.
@@ -11,26 +22,68 @@ export declare function resolvePlusMinusTriggerKeysForNudge(nudge: Pick<PlusMinu
 /** True when resolved increment and decrement would match the same key press. */
 export declare function plusMinusResolvedKeysConflict(nudge: Pick<PlusMinusNudge, 'IncrementKey' | 'DecrementKey'>, globalOptions: Readonly<EditOptions['plusMinusOptions']> | undefined): boolean;
 /**
- * Match a pressed key against a configured trigger. Single-character keys are
- * compared case-insensitively (aligned with Shortcut module behaviour).
+ * Match a pressed key (with its modifier state) against a configured trigger.
+ * Single-character triggers (including the defaults `+` / `-`) are compared
+ * case-insensitively against the pressed key. Multi-character triggers are
+ * parsed as keyboard shortcut combinations (e.g. `shift+Enter`) and delegated
+ * to {@link eventMatchesKeyboardShortcut}.
  */
-export declare function plusMinusKeyMatches(actualKey: string, configuredKey: string): boolean;
+export declare function plusMinusEventMatchesTrigger(event: PlusMinusKeyEvent, configuredKey: string): boolean;
 /** Increment key from `AdaptableOptions.plusMinusOptions` only, then built-in `+`. */
 export declare function plusMinusIncrementKeyFromOptionsOnly(globalOptions: Readonly<PlusMinusOptions> | undefined): string;
 /** Decrement key from `AdaptableOptions.plusMinusOptions` only, then built-in `-`. */
 export declare function plusMinusDecrementKeyFromOptionsOnly(globalOptions: Readonly<PlusMinusOptions> | undefined): string;
 /**
- * True when `candidate` is the same trigger as `baseline` for “no nudge override to persist”
- * (single-character keys compared case-insensitively, same as {@link plusMinusKeyMatches}).
+ * Canonical, comparable form of a trigger so equivalent descriptors compare
+ * equal regardless of case or modifier ordering (e.g. `Shift+Enter` and
+ * `shift+enter` normalise to the same value). Single characters are lowercased.
+ */
+export declare function normalizePlusMinusTrigger(trigger: string | undefined): string;
+/**
+ * True when `candidate` is the same trigger as `baseline` for “no nudge override
+ * to persist” (normalised comparison, see {@link normalizePlusMinusTrigger}).
  */
 export declare function plusMinusTriggerSameAsBaseline(candidate: string, baseline: string): boolean;
+/** Result of interpreting a key press inside a "record shortcut" UI. */
+export type PlusMinusCaptureResult = {
+    kind: 'pending';
+    modifiers: string[];
+} | {
+    kind: 'invalid';
+    reason: string;
+} | {
+    kind: 'captured';
+    trigger: string;
+};
+/**
+ * Interpret a key press (from a "record shortcut" UI, à la VS Code) into a
+ * Plus/Minus trigger:
+ * - `pending`: only modifier keys are held so far (waiting for a real key).
+ * - `captured`: a complete, representable trigger — a single literal character
+ *   (such as the default `+`), a named key (e.g. `Enter`), or a modifier
+ *   combination (e.g. `shift+Enter`).
+ * - `invalid`: the press cannot be represented as a trigger (e.g. a `+`
+ *   character combined with modifiers, since `+` is the glue between parts).
+ */
+export declare function capturePlusMinusTriggerFromEvent(event: PlusMinusKeyEvent): PlusMinusCaptureResult;
+/** Human-friendly label for a single trigger token (a modifier or a key). */
+export declare function plusMinusKeyLabel(token: string): string;
+/**
+ * Split a stored trigger into human-friendly key tokens for kbd-style display
+ * (e.g. `shift+Enter` -> `['Shift', 'Enter']`, `+` -> `['+']`).
+ */
+export declare function plusMinusTriggerDisplayParts(trigger: string): string[];
 /**
- * Precomputed keys for fast keydown filtering (mirrors {@link plusMinusKeyMatches} semantics).
- * Single-character triggers are stored lowercased; longer triggers are exact strings.
+ * Precomputed keys for fast keydown filtering. Stores the lowercased
+ * non-modifier key of each trigger (the default `+` / `-`, a literal single
+ * char, or the key part of a combination such as `enter` for `shift+Enter`),
+ * so a pressed `event.key` can be cheaply rejected before running nudge rules.
  */
 export type PlusMinusTriggerKeyLookup = {
-    singleCharLower: Set<string>;
-    exactKeys: Set<string>;
+    /** Lowercased non-modifier keys that could trigger a nudge. */
+    effectiveKeysLower: Set<string>;
+    /** True when a trigger uses the `*` wildcard, so any key could match. */
+    matchAnyKey: boolean;
 };
 /** Build a lookup of all increment/decrement keys across active nudges (resolved). */
 export declare function buildPlusMinusTriggerKeyLookup(nudges: PlusMinusNudge[], globalOptions: Readonly<PlusMinusOptions> | undefined): PlusMinusTriggerKeyLookup;