@adaptabletools/adaptable 23.0.5 → 23.0.7

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;

package/src/Utilities/Helpers/PlusMinusHelper.js

@@ -1,5 +1,12 @@
+import { eventMatchesKeyboardShortcut } from '@infinite-table/infinite-react';
 const DEFAULT_INCREMENT_KEY = '+';
 const DEFAULT_DECREMENT_KEY = '-';
+const MODIFIER_TOKENS = new Set(['cmd', 'meta', 'ctrl', 'control', 'alt', 'shift']);
+const MODIFIER_ALIASES = { control: 'ctrl', meta: 'cmd' };
+const KEY_ALIASES = { esc: 'escape' };
+function isPlusMinusCombination(trigger) {
+    return trigger.length > 1;
+}
 export function resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions) {
     const incrementKey = nudge.IncrementKey?.trim() || plusMinusIncrementKeyFromOptionsOnly(globalOptions);
     const decrementKey = nudge.DecrementKey?.trim() || plusMinusDecrementKeyFromOptionsOnly(globalOptions);
@@ -7,25 +14,32 @@ export function resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions) {
 }
 export function plusMinusResolvedKeysConflict(nudge, globalOptions) {
     const { incrementKey, decrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions);
-    if (incrementKey === decrementKey) {
-        return true;
-    }
-    if (incrementKey.length === 1 && decrementKey.length === 1) {
-        return incrementKey.toLowerCase() === decrementKey.toLowerCase();
+    const normalizedIncrement = normalizePlusMinusTrigger(incrementKey);
+    const normalizedDecrement = normalizePlusMinusTrigger(decrementKey);
+    if (!normalizedIncrement || !normalizedDecrement) {
+        return false;
     }
-    return false;
+    return normalizedIncrement === normalizedDecrement;
 }
-export function plusMinusKeyMatches(actualKey, configuredKey) {
-    if (!configuredKey) {
+export function plusMinusEventMatchesTrigger(event, configuredKey) {
+    const trigger = (configuredKey ?? '').trim();
+    if (!trigger) {
         return false;
     }
-    if (actualKey === configuredKey) {
-        return true;
+    const pressedKey = event?.key;
+    if (!pressedKey) {
+        return false;
     }
-    if (configuredKey.length === 1 && actualKey.length === 1) {
-        return actualKey.toLowerCase() === configuredKey.toLowerCase();
+    if (!isPlusMinusCombination(trigger)) {
+        return pressedKey.length === 1 && pressedKey.toLowerCase() === trigger.toLowerCase();
     }
-    return false;
+    return eventMatchesKeyboardShortcut({
+        key: pressedKey,
+        metaKey: !!event.metaKey,
+        altKey: !!event.altKey,
+        ctrlKey: !!event.ctrlKey,
+        shiftKey: !!event.shiftKey,
+    }, trigger);
 }
 export function plusMinusIncrementKeyFromOptionsOnly(globalOptions) {
     return globalOptions?.incrementKey?.trim() || DEFAULT_INCREMENT_KEY;
@@ -33,24 +47,165 @@ export function plusMinusIncrementKeyFromOptionsOnly(globalOptions) {
 export function plusMinusDecrementKeyFromOptionsOnly(globalOptions) {
     return globalOptions?.decrementKey?.trim() || DEFAULT_DECREMENT_KEY;
 }
+export function normalizePlusMinusTrigger(trigger) {
+    const value = (trigger ?? '').trim();
+    if (!value) {
+        return '';
+    }
+    if (!isPlusMinusCombination(value)) {
+        return value.toLowerCase();
+    }
+    const parts = value
+        .split('+')
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean);
+    const modifiers = [];
+    const keys = [];
+    for (const part of parts) {
+        if (MODIFIER_TOKENS.has(part)) {
+            modifiers.push(MODIFIER_ALIASES[part] ?? part);
+        }
+        else {
+            keys.push(KEY_ALIASES[part] ?? part);
+        }
+    }
+    modifiers.sort();
+    return [...modifiers, ...keys].join('+');
+}
 export function plusMinusTriggerSameAsBaseline(candidate, baseline) {
-    return plusMinusKeyMatches(candidate, baseline) && plusMinusKeyMatches(baseline, candidate);
+    return normalizePlusMinusTrigger(candidate) === normalizePlusMinusTrigger(baseline);
+}
+const MODIFIER_KEY_NAMES = new Set([
+    'Shift',
+    'Control',
+    'Alt',
+    'Meta',
+    'OS',
+    'AltGraph',
+    'CapsLock',
+    'NumLock',
+    'ScrollLock',
+    'Hyper',
+    'Super',
+    'Fn',
+    'FnLock',
+    'Dead',
+]);
+function activeModifierTokens(event) {
+    const tokens = [];
+    if (event.ctrlKey) {
+        tokens.push('ctrl');
+    }
+    if (event.altKey) {
+        tokens.push('alt');
+    }
+    if (event.metaKey) {
+        tokens.push('cmd');
+    }
+    if (event.shiftKey) {
+        tokens.push('shift');
+    }
+    return tokens;
+}
+export function capturePlusMinusTriggerFromEvent(event) {
+    const key = event?.key;
+    const modifiers = activeModifierTokens(event);
+    if (!key || MODIFIER_KEY_NAMES.has(key)) {
+        return { kind: 'pending', modifiers };
+    }
+    const isPrintable = key.length === 1;
+    const keyPart = isPrintable ? key.toLowerCase() : key;
+    if (!modifiers.length) {
+        return { kind: 'captured', trigger: keyPart };
+    }
+    const shiftOnly = modifiers.length === 1 && modifiers[0] === 'shift';
+    const isLetter = isPrintable && /^[a-z]$/.test(keyPart);
+    if (isPrintable && shiftOnly && !isLetter) {
+        return { kind: 'captured', trigger: keyPart };
+    }
+    if (keyPart.includes('+')) {
+        return { kind: 'invalid', reason: 'This key cannot be combined with modifiers.' };
+    }
+    return { kind: 'captured', trigger: [...modifiers, keyPart].join('+') };
+}
+const KEY_DISPLAY_LABELS = {
+    ctrl: 'Ctrl',
+    cmd: 'Cmd',
+    alt: 'Alt',
+    shift: 'Shift',
+    enter: 'Enter',
+    escape: 'Esc',
+    esc: 'Esc',
+    tab: 'Tab',
+    space: 'Space',
+    backspace: 'Backspace',
+    delete: 'Delete',
+    insert: 'Insert',
+    arrowup: '↑',
+    arrowdown: '↓',
+    arrowleft: '←',
+    arrowright: '→',
+    pageup: 'Page Up',
+    pagedown: 'Page Down',
+    home: 'Home',
+    end: 'End',
+};
+export function plusMinusKeyLabel(token) {
+    const value = (token ?? '').trim();
+    if (!value) {
+        return '';
+    }
+    const lower = value.toLowerCase();
+    if (KEY_DISPLAY_LABELS[lower]) {
+        return KEY_DISPLAY_LABELS[lower];
+    }
+    if (value.length === 1) {
+        return value;
+    }
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+export function plusMinusTriggerDisplayParts(trigger) {
+    const value = (trigger ?? '').trim();
+    if (!value) {
+        return [];
+    }
+    if (!isPlusMinusCombination(value)) {
+        return [plusMinusKeyLabel(value)];
+    }
+    return value
+        .split('+')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map(plusMinusKeyLabel);
 }
 function addConfiguredKeyToLookup(lookup, configuredKey) {
-    if (!configuredKey) {
+    const trigger = (configuredKey ?? '').trim();
+    if (!trigger) {
         return;
     }
-    if (configuredKey.length === 1) {
-        lookup.singleCharLower.add(configuredKey.toLowerCase());
+    if (!isPlusMinusCombination(trigger)) {
+        lookup.effectiveKeysLower.add(trigger.toLowerCase());
+        return;
     }
-    else {
-        lookup.exactKeys.add(configuredKey);
+    const parts = trigger
+        .split('+')
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean);
+    for (const part of parts) {
+        if (MODIFIER_TOKENS.has(part)) {
+            continue;
+        }
+        if (part === '*') {
+            lookup.matchAnyKey = true;
+            continue;
+        }
+        lookup.effectiveKeysLower.add(KEY_ALIASES[part] ?? part);
     }
 }
 export function buildPlusMinusTriggerKeyLookup(nudges, globalOptions) {
     const lookup = {
-        singleCharLower: new Set(),
-        exactKeys: new Set(),
+        effectiveKeysLower: new Set(),
+        matchAnyKey: false,
     };
     for (const nudge of nudges) {
         const { incrementKey, decrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions);
@@ -60,11 +215,11 @@ export function buildPlusMinusTriggerKeyLookup(nudges, globalOptions) {
     return lookup;
 }
 export function plusMinusKeyCouldTrigger(keyEventString, lookup) {
+    if (lookup.matchAnyKey) {
+        return true;
+    }
     if (!keyEventString) {
         return false;
     }
-    if (keyEventString.length === 1) {
-        return lookup.singleCharLower.has(keyEventString.toLowerCase());
-    }
-    return lookup.exactKeys.has(keyEventString);
+    return lookup.effectiveKeysLower.has(keyEventString.toLowerCase());
 }

package/src/View/Components/Popups/AdaptablePopup/AdaptablePopup.js

@@ -16,9 +16,9 @@ import { Box } from '../../../../components/Flex';
 export const AdaptablePopup = (props) => {
     const adaptable = useAdaptable();
     const settingsPanelOptions = adaptable.adaptableOptions.settingsPanelOptions;
+    const wizardOptions = adaptable.adaptableOptions.wizardOptions;
     const settingsPanelTitle = adaptable.ModuleService.getModuleFriendlyName('SettingsPanel');
     const menuItems = useMenuItems();
-    const isWindowModal = settingsPanelOptions.popupType === 'window';
     const modalContainer = resolveContainerElement(adaptable.adaptableOptions?.containerOptions?.modalContainer, props.api.internalApi.buildBaseContext());
     let friendlyName = null;
     let isStandalone = false;
@@ -54,6 +54,10 @@ export const AdaptablePopup = (props) => {
         activeItem = moduleInfo.ModuleName;
         moduleViewContent = (_jsx(AdaptablePopupBody, { api: props.api, module: module, componentName: props.componentName, moduleParams: props.moduleParams, onClearParams: props.onClearParams, onHide: props.onHide }));
     }
+    const effectivePopupType = isStandalone
+        ? wizardOptions?.popupType ?? settingsPanelOptions.popupType
+        : settingsPanelOptions.popupType;
+    const isWindowModal = effectivePopupType === 'window';
     const baseClassName = 'ab-Adaptable-Popup';
     const className = join(baseClassName, `${baseClassName}--${isWindowModal ? 'window' : 'modal'}`, isStandalone ? `${baseClassName}--action-popup` : `${baseClassName}--settings-popup`);
     return (_jsx(PopupContext.Provider, { value: {

package/src/View/Components/Popups/AdaptablePopup/AdaptablePopupDialog.js

@@ -11,17 +11,21 @@ const WindowDialog = (props) => {
     const adaptable = useAdaptable();
     const dispatch = useDispatch();
     const settingsPanelOptions = adaptable.adaptableOptions.settingsPanelOptions;
+    const wizardOptions = adaptable.adaptableOptions.wizardOptions;
     let popupSettings = useSelector((state) => state?.Internal?.SettingsPanel?.[settingsPanelOptionsKey]);
     const handleWindowSettings = (settings) => {
         dispatch(SettingsPanelSet(settingsPanelOptionsKey, settings));
     };
     if (!popupSettings) {
         const size = isActionModule
-            ? getActionPanelSize()
+            ? wizardOptions?.size ?? getActionPanelSize()
             : settingsPanelOptions.size ?? getSettingsPanelSize();
+        const position = isActionModule
+            ? wizardOptions?.position ?? getMiddlePosition(size)
+            : settingsPanelOptions.position ?? getMiddlePosition(size);
         popupSettings = {
-            size: size,
-            position: settingsPanelOptions.position ?? getMiddlePosition(size),
+            size,
+            position,
         };
     }
     const windowModalProps = {

package/src/View/Components/Popups/Utilities.d.ts

@@ -13,6 +13,17 @@ export declare const getSettingsPanelSize: () => {
     height: number;
     width: number;
 };
+/**
+ * Default size for the One Page Wizard when it renders as a window (i.e.
+ * `wizardOptions.popupType === 'window'` and the user has not provided an
+ * explicit `wizardOptions.size`). Mirrors the historical modal sizing of
+ * 90vh tall and 90vw wide, capped at 1200px wide so the wizard stays
+ * readable on very large monitors.
+ */
+export declare const getWizardSize: () => {
+    height: number;
+    width: number;
+};
 export declare const getWindowPopupSize: () => {
     height: number;
     width: number;

package/src/View/Components/Popups/Utilities.js

@@ -23,6 +23,14 @@ export const getSettingsPanelSize = () => {
         width: clamp(width * 0.9, 0, 800),
     };
 };
+export const getWizardSize = () => {
+    const height = window.innerHeight;
+    const width = window.innerWidth;
+    return {
+        height: height * 0.9,
+        width: clamp(width * 0.9, 0, 1200),
+    };
+};
 export const getWindowPopupSize = () => {
     return getSettingsPanelSize();
 };

package/src/View/DataChangeHistory/DataChangeHistoryViewPanel.js

@@ -21,10 +21,9 @@ export const DataChangeHistoryViewPanelControl = (props) => {
     const handleOpenPopup = React.useCallback(() => {
         adaptable.api.settingsPanelApi.openSettingsPanel('DataChangeHistory');
     }, []);
-    const dataChangeHistoryState = useSelector((state) => state.Internal.DataChangeHistory);
-    const changeHistoryMode = dataChangeHistoryState.currentMode;
-    const activationTime = dataChangeHistoryState.enableTime;
-    const suspensionTime = dataChangeHistoryState.suspendTime;
+    const changeHistoryMode = useSelector((state) => state.Internal.DataChangeHistory.currentMode);
+    const activationTime = useSelector((state) => state.Internal.DataChangeHistory.enableTime);
+    const suspensionTime = useSelector((state) => state.Internal.DataChangeHistory.suspendTime);
     const enabled = changeHistoryMode === 'ACTIVE';
     const disabled = changeHistoryMode === 'INACTIVE';
     const suspended = changeHistoryMode === 'SUSPENDED';

package/src/View/DataChangeHistory/dataChangeHistoryHelpers.js

@@ -21,7 +21,7 @@ export const mapChangeHistoryRowData = (changeHistoryLog = {}, mainAdaptableInst
         changedColumnLabel: getColumnHeaderLabel(changeInfo.column.columnId, mainAdaptableInstance),
         changeInfo,
     }))
-        .sort((a, b) => b.changeInfo.changedAt - a.changeInfo.changedAt);
+        .reverse();
 };
 export const getChangeHistoryRowChangeInfo = (rowData) => {
     if (!isValidChangeHistoryLogEntry(rowData?.changeInfo)) {

package/src/View/PlusMinus/Wizard/KeyComboCaptureInput.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+export interface KeyComboCaptureInputProps {
+    /** Resolved trigger to display when not recording (e.g. `+` or `shift+Enter`). */
+    value: string;
+    /** When true, `value` comes from the default/global setting (shown as a hint). */
+    isUsingDefault?: boolean;
+    /** Hint shown when there is no value and the field is not recording. */
+    placeholder?: string;
+    disabled?: boolean;
+    'data-name'?: string;
+    /** Called with a complete, valid trigger once the user records one. */
+    onCapture: (trigger: string) => void;
+    /** Reset back to the default/global trigger (clears the per-nudge override). */
+    onReset?: () => void;
+    /**
+     * Optional validation run on a captured trigger before committing.
+     * Return an error message to reject the capture (e.g. increment/decrement clash).
+     */
+    validateCapture?: (trigger: string) => string | undefined;
+}
+/**
+ * VS Code-style keyboard shortcut recorder. While focused the field shows the
+ * current value and a "Hit Enter to edit" hint; pressing Enter enters edit mode
+ * (the value is cleared) where the next key press / combination is detected from
+ * the event. A valid press is persisted and edit mode ends; incomplete
+ * (modifier-only) and unrepresentable presses are rejected, and an optional
+ * `validateCapture` guards against clashes. The revert button restores the
+ * default once a custom value has been set.
+ */
+export declare const KeyComboCaptureInput: React.FunctionComponent<KeyComboCaptureInputProps>;