@adaptabletools/adaptable 24.0.0-canary.1 → 24.0.0-canary.10

package/src/View/Wizard/CollapsibleWizardCard.js

@@ -21,28 +21,36 @@ export function renderCompactAccentTags(ids, getLabel, options) {
     return (_jsxs(Flex, { alignItems: "center", className: "twa:gap-1 twa:min-w-0 twa:overflow-hidden", children: [visibleIds.map((id) => (_jsx(AccentTag, { className: "twa:shrink-0", children: getLabel(id) }, id))), remainder > 0 ? (_jsxs("span", { className: "twa:text-xs twa:opacity-70 twa:shrink-0", children: ["+", remainder] })) : null] }));
 }
 export const CollapsibleWizardCard = (props) => {
-    const { title, help, collapsedHelp, summary, compactSummary, compactSummaryInteractive = false, headerVisual, headerActions, children, defaultExpanded = false, compact = false, fillAvailable = false, className, bodyClassName, surface = 'popup', 'data-name': dataName, } = props;
+    const { title, help, collapsedHelp, summary, compactSummary, compactSummaryInteractive = false, headerVisual, headerActions, children, collapsible = true, defaultExpanded = false, compact = false, fillAvailable = false, className, bodyClassName, surface = 'popup', 'data-name': dataName, } = props;
     const [expanded, setExpanded] = useProperty(props, 'expanded', defaultExpanded, {
         onChange: props.onExpandedChange,
     });
-    const showSummary = !expanded && !compact;
+    const canToggle = collapsible;
+    const isExpanded = canToggle && expanded;
+    const isCompact = canToggle && compact;
+    const showSummary = !isExpanded && !isCompact;
     const collapsedHeaderInline = collapsedHelp === false ? undefined : collapsedHelp ?? help;
-    const headerInline = expanded ? help : compact ? compactSummary : collapsedHeaderInline;
-    const isInteractiveCompactSummary = compact && compactSummaryInteractive;
-    const toggleExpanded = () => setExpanded(!expanded);
+    const headerInline = isExpanded ? help : isCompact ? compactSummary : collapsedHeaderInline;
+    const isInteractiveCompactSummary = isCompact && compactSummaryInteractive;
+    const toggleExpanded = () => {
+        if (!canToggle) {
+            return;
+        }
+        setExpanded(!expanded);
+    };
     const handleTitleKeyDown = (event) => {
         if (event.key === 'Enter' || event.key === ' ') {
             event.preventDefault();
             toggleExpanded();
         }
     };
-    return (_jsxs(Card, { shadow: false, className: cn('ab-CollapsibleWizardCard twa:border twa:transition-[border-color,background-color]', expanded
+    return (_jsxs(Card, { shadow: false, className: cn('ab-CollapsibleWizardCard twa:border twa:transition-[border-color,background-color]', isExpanded
             ? getCollapsibleWizardCardExpandedClasses(surface)
-            : getCollapsibleWizardCardCollapsedClasses(surface), compact && 'ab-CollapsibleWizardCard--compact twa:p-0!', fillAvailable
+            : getCollapsibleWizardCardCollapsedClasses(surface), isCompact && 'ab-CollapsibleWizardCard--compact twa:p-0!', fillAvailable
             ? 'twa:flex-1 twa:min-h-0 twa:flex twa:flex-col twa:overflow-hidden'
-            : 'twa:shrink-0', className), children: [_jsx(Card.Title, { className: "twa:p-0", border: !compact, children: _jsxs(Box, { className: cn('twa:flex twa:flex-row twa:items-center twa:gap-2 twa:w-full twa:px-2 twa:cursor-pointer twa:rounded-standard twa:hover:bg-primary', { 'twa:py-2': true, 'twa:mb-0.5': !compact && !expanded }, targetOwn.focusOutline, 'twa:focus-visible:ring-inset'), "data-name": dataName, onClick: toggleExpanded, onKeyDown: handleTitleKeyDown, tabIndex: 0, "aria-expanded": expanded, role: "button", children: [_jsxs(Box, { className: "twa:flex twa:flex-row twa:items-center twa:gap-2 twa:shrink-0 twa:cursor-pointer twa:select-none", children: [_jsx(IconComponent, { icon: { name: expanded ? 'collapse' : 'expand' } }), _jsx(Box, { className: "twa:font-medium", children: title })] }), headerVisual ? (_jsx(Box, { className: "twa:flex-1 twa:min-w-0 twa:flex twa:justify-end twa:items-center twa:overflow-hidden twa:pointer-events-none", children: headerVisual })) : headerInline ? (_jsx(Box, { className: cn('twa:flex-1 twa:min-w-0 twa:font-normal', isInteractiveCompactSummary
+            : 'twa:shrink-0', className), children: [_jsx(Card.Title, { className: "twa:p-0", border: !isCompact, children: _jsxs(Box, { className: cn('twa:flex twa:flex-row twa:items-center twa:gap-2 twa:w-full twa:px-2 twa:rounded-standard', canToggle && 'twa:cursor-pointer twa:hover:bg-primary', { 'twa:py-2': true, 'twa:mb-0.5': !isCompact && !isExpanded }, canToggle && targetOwn.focusOutline, canToggle && 'twa:focus-visible:ring-inset'), "data-name": dataName, onClick: canToggle ? toggleExpanded : undefined, onKeyDown: canToggle ? handleTitleKeyDown : undefined, tabIndex: canToggle ? 0 : undefined, "aria-expanded": canToggle ? isExpanded : undefined, role: canToggle ? 'button' : undefined, children: [_jsxs(Box, { className: cn('twa:flex twa:flex-row twa:items-center twa:gap-2 twa:shrink-0 twa:select-none', canToggle && 'twa:cursor-pointer'), children: [canToggle ? (_jsx(IconComponent, { icon: { name: isExpanded ? 'collapse' : 'expand' } })) : null, _jsx(Box, { className: "twa:font-medium", children: title })] }), headerVisual ? (_jsx(Box, { className: "twa:flex-1 twa:min-w-0 twa:flex twa:justify-end twa:items-center twa:overflow-hidden twa:pointer-events-none", children: headerVisual })) : headerInline ? (_jsx(Box, { className: cn('twa:flex-1 twa:min-w-0 twa:font-normal', isInteractiveCompactSummary
                                 ? 'twa:flex twa:justify-end twa:items-center twa:overflow-visible'
-                                : cn('twa:text-xs twa:opacity-70 twa:pointer-events-none twa:cursor-default', compact ? 'twa:overflow-hidden' : 'twa:truncate')), children: headerInline })) : (_jsx(Box, { className: "twa:flex-1 twa:min-w-0" })), headerActions ? (_jsx(Box, { className: "twa:shrink-0 twa:gap-2 twa:flex", onClick: (event) => event.stopPropagation(), children: headerActions })) : null] }) }), expanded ? (_jsx(Card.Body, { className: cn('twa:p-1', bodyClassName, fillAvailable && 'twa:max-h-none! twa:flex-1 twa:min-h-0'), children: children })) : showSummary ? (_jsx(Card.Body, { className: "twa:p-1", gap: 1, children: summary })) : null] }));
+                                : cn('twa:text-xs twa:opacity-70 twa:pointer-events-none twa:cursor-default', isCompact ? 'twa:overflow-hidden' : 'twa:truncate')), children: headerInline })) : (_jsx(Box, { className: "twa:flex-1 twa:min-w-0" })), headerActions ? (_jsx(Box, { className: "twa:shrink-0 twa:gap-2 twa:flex", onClick: (event) => event.stopPropagation(), children: headerActions })) : null] }) }), isExpanded ? (_jsx(Card.Body, { className: cn('twa:p-1', bodyClassName, fillAvailable && 'twa:max-h-none! twa:flex-1 twa:min-h-0'), children: children })) : showSummary ? (_jsx(Card.Body, { className: "twa:p-1", gap: 1, children: summary })) : null] }));
 };
 export function useWizardCardAccordion(initialExpandedId, options) {
     const fillExpandedCard = options?.fillExpandedCard ?? false;

package/src/agGrid/Adaptable.d.ts

@@ -1,7 +1,6 @@
 import { AgGridConfig } from '../AdaptableInterfaces/IAdaptable';
 import { AdaptableOptions } from '../AdaptableOptions/AdaptableOptions';
 import { AdaptableApi } from '../Api/AdaptableApi';
-import { AdaptableNoCodeWizardOptions, IAdaptableNoCodeWizard } from '../AdaptableInterfaces/AdaptableNoCodeWizard';
 export declare class Adaptable {
     /**
      * Initializer for Adaptable
@@ -12,14 +11,3 @@ export declare class Adaptable {
      */
     static init(adaptableOptions: AdaptableOptions, agGridConfig: AgGridConfig): Promise<AdaptableApi>;
 }
-export declare class AdaptableNoCodeWizard implements IAdaptableNoCodeWizard {
-    private init;
-    private adaptableOptions;
-    private extraOptions;
-    private agGridModules;
-    /**
-     * @param adaptableOptions
-     */
-    constructor(adaptableOptions: AdaptableOptions, extraOptions?: AdaptableNoCodeWizardOptions, agGridOptions?: AgGridConfig);
-    render(container?: HTMLElement | null): void;
-}

package/src/agGrid/Adaptable.js

@@ -1,11 +1,6 @@
-import * as React from 'react';
 import { AgGridModulesDocsLink } from '../Utilities/Constants/DocumentationLinkConstants';
 import { AdaptableLogger } from './AdaptableLogger';
 import { AdaptableAgGrid } from './AdaptableAgGrid';
-import { getDefaultAdaptableOptions } from '../AdaptableOptions/DefaultAdaptableOptions';
-import { renderReactRoot as defaultRenderReactRoot } from '../renderReactRoot';
-import AdaptableWizardView from '../View/AdaptableWizardView';
-import { resolveContainerElement } from '../Utilities/resolveContainerElement';
 export class Adaptable {
     static init(adaptableOptions, agGridConfig) {
         if (!agGridConfig?.modules?.length) {
@@ -14,50 +9,3 @@ export class Adaptable {
         return AdaptableAgGrid._initInternal({ ...agGridConfig, adaptableOptions, variant: 'vanilla' });
     }
 }
-export class AdaptableNoCodeWizard {
-    init;
-    adaptableOptions;
-    extraOptions;
-    agGridModules;
-    constructor(adaptableOptions, extraOptions = {}, agGridOptions) {
-        const defaultInit = async ({ gridOptions, adaptableOptions, agGridModules, }) => {
-            return await Adaptable.init(adaptableOptions, { gridOptions, modules: agGridModules });
-        };
-        this.adaptableOptions = adaptableOptions;
-        this.init = extraOptions.onInit || defaultInit;
-        this.extraOptions = extraOptions;
-        this.agGridModules = [];
-        this.render();
-    }
-    render(container) {
-        if (!container) {
-            const initContext = {
-                adaptableId: this.adaptableOptions?.adaptableId ?? '',
-                adaptableStateKey: this.adaptableOptions?.adaptableStateKey ?? '',
-                adaptableContext: this.adaptableOptions?.adaptableContext,
-            };
-            container = resolveContainerElement(this.adaptableOptions.containerOptions?.adaptableContainer, initContext);
-        }
-        if (!container) {
-            const defaultId = getDefaultAdaptableOptions().containerOptions.adaptableContainer || 'adaptable';
-            container = document.getElementById(defaultId);
-        }
-        if (!container) {
-            throw new Error('Cannot find container in which to render Adaptable No Code Wizard');
-        }
-        container.classList.add('adaptable--in-wizard');
-        const unmount = defaultRenderReactRoot(React.createElement(AdaptableWizardView, {
-            adaptableOptions: this.adaptableOptions,
-            ...this.extraOptions,
-            onInit: (adaptableOptions, gridOptions) => {
-                container.classList.remove('adaptable--in-wizard');
-                unmount();
-                this.init({
-                    adaptableOptions,
-                    gridOptions: gridOptions,
-                    agGridModules: [...this.agGridModules],
-                });
-            },
-        }), container);
-    }
-}

package/src/agGrid/AdaptableAgGrid.d.ts

@@ -7,7 +7,7 @@ import { EmitterCallback } from '../Utilities/Emitter';
 import { AdaptablePlugin } from '../AdaptableOptions/AdaptablePlugin';
 import { AgGridAdapter, RowNodeEvent } from './AgGridAdapter';
 import { IDataService } from '../Utilities/Services/Interface/IDataService';
-import { AdaptableState } from '../AdaptableState/AdaptableState';
+import { AdaptablePersistentState } from '../AdaptableState/AdaptableState';
 import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
 import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
 import { IModuleService } from '../Utilities/Services/Interface/IModuleService';
@@ -157,9 +157,9 @@ export declare class AdaptableAgGrid implements IAdaptable {
     static _initInternal(config: AdaptableInitInternalConfig): Promise<AdaptableApi>;
     private _initAdaptableAgGrid;
     midwayDestroy(): void;
-    migrateLoadedAdaptableState(state: AdaptableState): AdaptableState;
-    buildPostLoadHook(gridOptions: NormalizeAdaptableStateOptions): (state: AdaptableState) => AdaptableState;
-    normalizeAdaptableState(state: AdaptableState, agGridOptions: NormalizeAdaptableStateOptions): AdaptableState;
+    migrateLoadedAdaptableState<T extends Partial<AdaptablePersistentState>>(state: T): T;
+    buildPostLoadHook(gridOptions: NormalizeAdaptableStateOptions): (state: Partial<AdaptablePersistentState>) => Partial<AdaptablePersistentState>;
+    normalizeAdaptableState(state: Partial<AdaptablePersistentState>, agGridOptions: NormalizeAdaptableStateOptions): Partial<AdaptablePersistentState>;
     private normaliseLayoutState;
     private normaliseToolPanelState;
     private getCurrentLayoutModel;

package/src/agGrid/AdaptableAgGrid.js

@@ -15,6 +15,7 @@ import { AG_GRID_GRAND_TOTAL_ROW_ID, AG_GRID_GROUPED_COLUMN, AG_GRID_SELECTION_C
 import { generateSelectionColumn } from '../Api/Implementation/ColumnApiImpl';
 import { DataService } from '../Utilities/Services/DataService';
 import { AdaptableStore } from '../Redux/Store/AdaptableStore';
+import { validateStateOptions } from '../Redux/Store/StateOptionsGuards';
 import { AdaptableApiImpl } from '../Api/Implementation/AdaptableApiImpl';
 import { Fdc3Service } from '../Utilities/Services/Fdc3Service';
 import { CommentsService } from '../Utilities/Services/CommentsService';
@@ -739,6 +740,7 @@ export class AdaptableAgGrid {
         }
     }
     normalizeAdaptableOptions(adaptableOptions) {
+        validateStateOptions(adaptableOptions.stateOptions, this.logger);
         if (this.hasAutogeneratedPrimaryKey) {
             this.logger.warn(`Autogenerated primary key is enabled (adaptableOptions.autogeneratedPrimaryKey = true). This should be a last resort as it limits some Adaptable features. See: ${PrimaryKeyDocsLink}`);
             this.adaptableOptions.primaryKey = AUTOGENERATED_PK_COLUMN;

package/src/agGrid/AdaptableFrameworkComponent.d.ts

@@ -29,7 +29,13 @@ export type ReactFrameworkComponent = ({ adaptableApi, }: {
 }) => ReactElement;
 /** AdapTable extras passed on AG Grid `menuItemParams` for custom menu items. */
 export interface AdaptableMenuItemParams<TMenuContext = unknown> {
+    /**
+     * AdapTable API for the grid that opened the menu.
+     */
     adaptableApi: AdaptableApi;
+    /**
+     * Column menu or context menu context: the column, the row, and the cell the menu was opened on.
+     */
     menuContext: TMenuContext;
 }
 /**
@@ -37,7 +43,13 @@ export interface AdaptableMenuItemParams<TMenuContext = unknown> {
  * `menuItemParams` (see `AgGridMenuAdapter.mapCustomMenuItemToAgGridMenuDefinition`).
  */
 export interface AdaptableReactMenuItemProps<TMenuContext = unknown> {
+    /**
+     * Menu item name AG Grid passes to the component.
+     */
     name: string;
+    /**
+     * AdapTable extras (`adaptableApi`, `menuContext`) plus anything supplied on the menu item.
+     */
     menuItemParams: AdaptableMenuItemParams<TMenuContext> & Record<string, unknown>;
 }
 /**

package/src/agGrid/AdaptableLogger.d.ts

@@ -2,30 +2,103 @@ import { AdaptableMessageType } from '../AdaptableState/Common/AdaptableMessageT
 export declare const errorOnce: (message: string) => void;
 export declare const warnOnce: (message: string) => void;
 /**
- * AdapTable's Logger
+ * Logger for one AdapTable instance.
+ *
+ * `info`, `success`, `warn` and `error` write through the debug logger (namespaced `Adaptable:<adaptableId>`).
+ * `consoleInfo`, `consoleLog`, `consoleWarn` and `consoleError` write straight to the console, with the same prefix.
  */
 export declare class AdaptableLogger {
     private adaptableId;
+    /** Root debug logger, namespaced `Adaptable:<adaptableId>`. The public methods write through this. */
     private debugger;
+    /** Debug logger used by {@link AdaptableLogger.info}. */
     private infoLogger;
+    /** Debug logger used by {@link AdaptableLogger.success}. */
     private successLogger;
+    /** Debug logger used by {@link AdaptableLogger.warn}. */
     private warnLogger;
+    /** Debug logger used by {@link AdaptableLogger.error}. */
     private errorLogger;
+    /** Debug logger used by {@link AdaptableLogger.beginPerf}. */
     private perfLogger;
     static consoleErrorBase(message: string, ...optionalParams: any[]): void;
     static consoleWarnBase(message: string, ...optionalParams: any[]): void;
     static consoleLogBase(message: string, ...optionalParams: any[]): void;
+    /**
+     * @param adaptableId Id of the AdapTable instance, used as the log prefix
+     */
     constructor(adaptableId: string);
+    /**
+     * Starts a performance span. Call `end` on the returned object to log the elapsed milliseconds.
+     *
+     * @param sectionName Label included in the begin and end lines
+     * @returns An object whose `end` logs the duration
+     */
     beginPerf(sectionName: string): {
         end: (additionalComment?: string) => void;
     };
+    /**
+     * Writes an informational message to the `info` debug logger.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     info(message: string, ...optionalParams: any[]): void;
+    /**
+     * Writes a success message to the `success` debug logger.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     success(message: string, ...optionalParams: any[]): void;
+    /**
+     * Writes a warning to the `warn` debug logger.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     warn(message: string, ...optionalParams: any[]): void;
+    /**
+     * Writes an error to the `error` debug logger.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     error(message: string, ...optionalParams: any[]): void;
+    /**
+     * Writes to the console at the level of `messageType` (`Info`, `Success`, `Warning` or `Error`), prefixed with the AdapTable id.
+     *
+     * @param message Message text
+     * @param messageType Which console method to use
+     * @param optionalParams Extra values appended to the log
+     */
     consoleLogByMessageType(message: string, messageType: AdaptableMessageType, ...optionalParams: any[]): void;
+    /**
+     * Writes to `console.info`, prefixed with the AdapTable id.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     consoleInfo(message: string, ...optionalParams: any[]): void;
+    /**
+     * Writes to `console.log`, prefixed with the AdapTable id.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     consoleLog(message: string, ...optionalParams: any[]): void;
+    /**
+     * Writes to `console.warn`, prefixed with the AdapTable id.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     consoleWarn(message: string, ...optionalParams: any[]): void;
+    /**
+     * Writes to `console.error`, prefixed with the AdapTable id.
+     *
+     * @param message Message text
+     * @param optionalParams Extra values appended to the log
+     */
     consoleError(message: string, ...optionalParams: any[]): void;
 }

package/src/agGrid/AgGridColumnAdapter.d.ts

@@ -88,7 +88,7 @@ export declare class AgGridColumnAdapter {
     private setupColumnHeaderStyle;
     private setupColumnCellEditor;
     private setupColumnCellRenderer;
-    private setupColumnTooltipValueGetter;
+    private setupColumnTooltip;
     /**
      * Resolves a Range Bar bound (number / column id / Col-Min / Col-Max /
      * Col-Avg / Col-Median) into a concrete numeric value for the supplied row.

package/src/agGrid/AgGridColumnAdapter.js

@@ -67,7 +67,7 @@ const STABLE_CALLBACK_COL_DEF_PROPERTIES = new Set([
     'pivotComparator',
     'getFindText',
     'getQuickFilterText',
-    'tooltipValueGetter',
+    'tooltip',
     'cellEditorParams',
     'suppressNoteActions',
 ]);
@@ -333,7 +333,7 @@ export class AgGridColumnAdapter {
         this.setupColumnHeaderStyle(colSetupInfo);
         this.setupColumnHeaderClass(colSetupInfo);
         this.setupColumnValueGetter(colSetupInfo);
-        this.setupColumnTooltipValueGetter(colSetupInfo);
+        this.setupColumnTooltip(colSetupInfo);
         if (!isAutoRowGroupColumn) {
             this.setupColumnFilter(colSetupInfo);
             this.setupColumnFloatingFilter(colSetupInfo);
@@ -676,9 +676,9 @@ export class AgGridColumnAdapter {
             }
         });
     }
-    setupColumnTooltipValueGetter({ col, colId, abColumn }) {
+    setupColumnTooltip({ col, colId, abColumn }) {
         let hasTooptip = false;
-        this.setColDefProperty(col, 'tooltipValueGetter', () => {
+        this.setColDefProperty(col, 'tooltip', () => {
             const styledColumn = this.adaptableApi.styledColumnApi.getStyledColumnForColumnId(colId);
             if (!styledColumn || styledColumn.IsSuspended) {
                 return undefined;
@@ -928,6 +928,9 @@ export class AgGridColumnAdapter {
         return this.adaptableFloatingFilterComponent;
     }
     setupColumnFloatingFilter({ col, colDef }) {
+        if (!this.adaptableOptions.filterOptions.useAdaptableFiltering) {
+            return;
+        }
         const userProvidedFilterProp = this.getUserColDefProperty(col.getColId(), 'filter');
         const hasInvalidFilterProp = typeof userProvidedFilterProp !== 'boolean' &&
             typeof userProvidedFilterProp?.handler !== 'function' &&
@@ -938,7 +941,6 @@ export class AgGridColumnAdapter {
         }
         const isFloatingFilterDisabled = !colDef.filter ||
             !colDef.floatingFilter ||
-            !this.adaptableOptions.filterOptions.useAdaptableFiltering ||
             !this.adaptableApi.filterApi.columnFilterApi.isQuickFilterVisible();
         if (this.adaptableApi.columnApi.isAutoRowGroupColumnForMulti(col.getColId())) {
             this.setColDefProperty(col, 'floatingFilter', (original_floatingFilter) => {

package/src/agGrid/editors/AdaptableDateEditor/index.d.ts

@@ -5,6 +5,9 @@ import { IAdaptable } from '../../../AdaptableInterfaces/IAdaptable';
  * Params used by the AdapTable Date Editor
  */
 export interface AdaptableDateEditorParams extends ICellEditorParams {
+    /**
+     * AG Grid callback. The editor calls this with the selected date, or `null` when the date is cleared.
+     */
     onValueChange?: (value: any) => void;
 }
 export declare const AdaptableReactDateEditor: React.ForwardRefExoticComponent<AdaptableDateEditorParams & React.RefAttributes<unknown>>;

package/src/agGrid/editors/AdaptableNumberEditor/index.d.ts

@@ -15,6 +15,9 @@ export interface AdaptableNumberCellEditorParams extends ICellEditorParams {
      * @defaultValue '' (empty string)
      */
     emptyValue: string;
+    /**
+     * AG Grid callback. The editor calls this with the value as the user edits, so the grid can commit it.
+     */
     onValueChange: (value: any) => void;
 }
 export declare const AdaptableReactNumberEditor: React.ForwardRefExoticComponent<AdaptableNumberCellEditorParams & React.RefAttributes<unknown>>;

package/src/agGrid/index.d.ts

@@ -1,11 +1,6 @@
-import { Adaptable, AdaptableNoCodeWizard as ABWizard } from './Adaptable';
+import { Adaptable } from './Adaptable';
 import { AdaptableLogger as ABLogger } from './AdaptableLogger';
-export { default as AdaptableWizardView } from '../View/AdaptableWizardView';
 export default Adaptable;
-/**
- * AdapTable's No Code Wizard
- */
-export declare const AdaptableNoCodeWizard: typeof ABWizard;
 /**
  * AdapTable's Logger
  */

package/src/agGrid/index.js

@@ -1,6 +1,4 @@
-import { Adaptable, AdaptableNoCodeWizard as ABWizard, } from './Adaptable';
+import { Adaptable } from './Adaptable';
 import { AdaptableLogger as ABLogger } from './AdaptableLogger';
-export { default as AdaptableWizardView } from '../View/AdaptableWizardView';
 export default Adaptable;
-export const AdaptableNoCodeWizard = ABWizard;
 export const AdaptableLogger = ABLogger;

package/src/aql/ExpressionEvaluation.d.ts

@@ -9,12 +9,27 @@ import type { CellDataChangedInfo } from '../AdaptableState/Common/CellDataChang
  * throws — check `success` and read `value` / `errorMessage` accordingly.
  */
 export type ExpressionEvaluationResult<T> = {
+    /**
+     * The expression evaluated. Read `value`.
+     */
     success: true;
+    /**
+     * Result of the expression.
+     */
     value: T;
 } | {
+    /**
+     * The expression did not evaluate. Read `errorMessage`. The API does not throw for these failures.
+     */
     success: false;
+    /**
+     * Why evaluation failed: a syntax error, an unknown column, a missing row, or a function that is not available.
+     */
     errorMessage: string;
 };
+/**
+ * Options shared by the `expressionApi` evaluate and filter calls.
+ */
 export interface EvaluateExpressionOptions {
     /**
      * Emulate a specific feature module's filtered function pool (e.g. "would
@@ -32,7 +47,13 @@ export interface EvaluateExpressionOptions {
  * When a `columnId` is both a grid column and listed here, this override wins.
  */
 export interface ExternalDataColumn {
+    /**
+     * Key on the plain-object row this metadata describes. Matches a grid `colId` when the key is also a column.
+     */
     columnId: string;
+    /**
+     * How to treat the value. When this key is also a grid column, this type wins over the column's data type.
+     */
     dataType?: 'number' | 'text' | 'date' | 'boolean' | 'array';
 }
 /**
@@ -40,7 +61,13 @@ export interface ExternalDataColumn {
  * Does not mutate grid (or data-set) data; other rows are unaffected.
  */
 export interface CellValueOverride {
+    /**
+     * Column whose value is replaced for this evaluation only.
+     */
     columnId: string;
+    /**
+     * Value used in place of the cell's current value. The grid data is not changed.
+     */
     value: unknown;
 }
 /**

package/src/aql/types.d.ts

@@ -24,10 +24,22 @@ context: AdaptableExpressionContext) => any;
  * Defines how an AdaptableQL Function is described in Expression Editor
  */
 export type ExpressionFunctionDocBlock = {
+    /**
+     * A code sample, shown as code in the Expression Editor.
+     */
     type: 'code';
+    /**
+     * The sample, for example `[price] > 100`.
+     */
     content: string;
 } | {
+    /**
+     * A prose description, shown as a paragraph in the Expression Editor.
+     */
     type: 'paragraph';
+    /**
+     * The description text.
+     */
     content: string;
 };
 /**
@@ -289,7 +301,17 @@ export type AdaptableAggregationFunctionMap<T extends string = string> = Record<
  * (not Layout / Cell Summary — those are aggregation-only).
  */
 export type AdaptableCustomExpressionFunction = Omit<AqlExpressionFunction<AdaptableExpressionContext> & AdaptableExpressionFunctionEnhancement, 'isAvailable' | 'returnType'> & {
+    /**
+     * Type the function returns. `boolean` makes it a predicate that can appear in the Query Builder and Column Filter when it takes one or two operands.
+     *
+     * Use an {@link ExpressionReturnType} value. `string & {}` keeps autocomplete while still accepting a widened string.
+     */
     returnType: ExpressionReturnType | (string & {});
+    /**
+     * Modules that may call this function, or a function of the availability context that returns whether it may be called.
+     *
+     * Omit it to allow the function in every standard-expression module. Layout and Cell Summary are aggregated-expression modules and are not in this list.
+     */
     isAvailable?: AdaptableStandardExpressionModule[] | ((context: ExpressionFunctionAvailabilityContext) => boolean);
 };
 /**

package/src/components/ColorField/index.d.ts

@@ -0,0 +1,13 @@
+import { type ColorFieldProps as SharedColorFieldProps } from "../../../vendor/components/ColorField";
+export type ColorFieldProps = Omit<SharedColorFieldProps, 'onChange' | 'clearable' | 'data-name' | 'filterColours'> & {
+    'data-name'?: string;
+} & ({
+    clearable?: true;
+    onChange: (color: string | undefined) => void;
+} | {
+    /** The colour is required, so there is no clear button and `onChange` always gets one. */
+    clearable: false;
+    onChange: (color: string) => void;
+});
+/** The shared colour field with AdapTable's defaults. */
+export declare const ColorField: (props: ColorFieldProps) => import("react").JSX.Element;

package/src/components/ColorField/index.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ColorField as SharedColorField, } from "../../../vendor/components/ColorField";
+import { useAdaptable } from '../../View/AdaptableContext';
+import { useOnePageAdaptableWizardContext } from '../../View/Wizard/OnePageAdaptableWizard';
+function useEditedModule() {
+    const wizard = useOnePageAdaptableWizardContext();
+    const adaptable = useAdaptable();
+    const fromWizard = wizard.moduleInfo?.ModuleName;
+    if (fromWizard) {
+        return fromWizard;
+    }
+    const screenPopup = adaptable?.adaptableStore?.TheStore.getState().Popup.ScreenPopup;
+    return screenPopup?.ShowScreenPopup ? screenPopup.ComponentModule : undefined;
+}
+const DEFAULT_TABS = ['Custom', 'Palette'];
+const showAllColours = () => undefined;
+export const ColorField = (props) => {
+    const adaptable = useAdaptable();
+    const module = useEditedModule();
+    const paletteOptions = adaptable?.api.optionsApi.getUserInterfaceOptions().colourPickerOptions;
+    const filterColours = paletteOptions?.filterColours;
+    const { onChange, tabs, orderPaletteColours, removeDuplicates, showGroupLabels, 'data-name': dataName = 'color-field', ...rest } = props;
+    return (_jsx(SharedColorField, { ...rest, "data-name": dataName, tabs: tabs ?? paletteOptions?.tabs ?? DEFAULT_TABS, orderPaletteColours: orderPaletteColours ?? paletteOptions?.orderPaletteColours, removeDuplicates: removeDuplicates ?? paletteOptions?.removeDuplicates, showGroupLabels: showGroupLabels ?? paletteOptions?.showGroupLabels, filterColours: filterColours
+            ? (colours) => filterColours({ ...colours, module })
+            : showAllColours, onChange: onChange }));
+};

package/src/components/aql/QueryBuilder/GroupEditor.js

@@ -31,7 +31,7 @@ export const GroupEditor = ({ node, path, isRoot, dispatch, hideDelete, }) => {
     };
     return (_jsxs(Box, { className: cn('ab-QueryBuilder__group twa:my-1', !isRoot &&
             'twa:pl-3 twa:border-l twa:rounded-md twa:py-1 twa:pr-1 ' +
-                'twa:bg-(--ab-cmp-query-builder-group__background)'), children: [showHeader && (_jsxs(Flex, { alignItems: "center", className: "twa:gap-2 twa:my-1", children: [showCombinator && (_jsx(CombinatorSelector, { value: node.combinator, onChange: (combinator) => dispatch({ type: 'setCombinator', groupPath: path, combinator }) })), _jsx(Box, { className: "twa:flex-1" }), showGroupDelete && (_jsx(RowActions, { rail: qb.hideInlineAdd ? 'compact' : 'full', hideAdd: true, onDelete: () => dispatch({ type: 'delete', path }) }))] })), isEmpty ? (_jsx(PrimitiveEditor, { node: emptyQlPrimitive(), path: [...path, 0], dispatch: seedDispatch, hideAdd: true, hideDelete: true })) : (_jsxs(_Fragment, { children: [hideDragHandles ? (_jsx("div", { className: "ab-QueryBuilder__group-children", children: node.children.map((child, index) => (_jsx(Flex, { className: "ab-QueryBuilder__row", alignItems: "center", children: _jsx(Box, { className: "ab-QueryBuilder__row-body twa:flex-1 twa:min-w-0", children: _jsx(NodeEditor, { node: child, path: [...path, index], dispatch: dispatch }) }) }, `${listId}/${index}`))) })) : (_jsx(DragList, { dragListId: listId, orientation: "vertical", onDrop: handleDrop, onDragProxyMove: defaultDragProxyMove, children: (listDomProps) => (_jsx("div", { ...listDomProps, className: cn('ab-QueryBuilder__group-children', listDomProps.className), children: node.children.map((child, index) => {
+                'twa:bg-(--ab-cmp-query-builder-group__background)'), children: [showHeader && (_jsxs(Flex, { alignItems: "center", className: "twa:gap-2 twa:my-1 twa:w-full", children: [showCombinator && (_jsx(CombinatorSelector, { value: node.combinator, onChange: (combinator) => dispatch({ type: 'setCombinator', groupPath: path, combinator }) })), _jsx(Box, { className: "twa:flex-1" }), showGroupDelete && (_jsx(RowActions, { rail: qb.hideInlineAdd ? 'compact' : 'full', hideAdd: true, onDelete: () => dispatch({ type: 'delete', path }) })), isRoot && showCombinator && qb.rootHeaderEnd] })), isEmpty ? (_jsx(PrimitiveEditor, { node: emptyQlPrimitive(), path: [...path, 0], dispatch: seedDispatch, hideAdd: true, hideDelete: true })) : (_jsxs(_Fragment, { children: [hideDragHandles ? (_jsx("div", { className: "ab-QueryBuilder__group-children", children: node.children.map((child, index) => (_jsx(Flex, { className: "ab-QueryBuilder__row", alignItems: "center", children: _jsx(Box, { className: "ab-QueryBuilder__row-body twa:flex-1 twa:min-w-0", children: _jsx(NodeEditor, { node: child, path: [...path, index], dispatch: dispatch }) }) }, `${listId}/${index}`))) })) : (_jsx(DragList, { dragListId: listId, orientation: "vertical", onDrop: handleDrop, onDragProxyMove: defaultDragProxyMove, children: (listDomProps) => (_jsx("div", { ...listDomProps, className: cn('ab-QueryBuilder__group-children', listDomProps.className), children: node.children.map((child, index) => {
                                 const childId = `${listId}/${index}`;
                                 return (_jsx(DragList.DraggableItem, { id: childId, children: (itemDomProps) => {
                                         const { onPointerDown, ...rest } = itemDomProps;

package/src/components/aql/QueryBuilder/QueryBuilder.d.ts

@@ -88,5 +88,10 @@ export interface QueryBuilderProps {
      * @defaultValue 'auto'
      */
     layout?: QueryBuilderLayoutMode;
+    /**
+     * Extra control on the right of the root AND/OR row, once there are
+     * two or more conditions. Hidden while the editor has a single condition.
+     */
+    rootHeaderEnd?: React.ReactNode;
 }
 export declare const QueryBuilder: React.FunctionComponent<QueryBuilderProps>;

package/src/components/aql/QueryBuilder/QueryBuilder.js

@@ -104,7 +104,7 @@ export const QueryBuilder = (props) => {
                             : 'query-builder2-invalid-expression', className: "twa:my-2 twa:w-full twa:max-w-full twa:text-2 twa:leading-snug twa:bg-background twa:text-foreground", children: _jsxs(Flex, { flexDirection: "column", className: "twa:gap-3", alignItems: "flex-start", children: [_jsxs(Flex, { flexDirection: "column", className: "twa:gap-2", children: [_jsx(Box, { children: primaryLine }), typeMismatchMessages.map((message) => (_jsx(Box, { children: message }, message))), _jsx(Box, { children: "Please edit the Expression in the Expression Editor." })] }), clearExpressionButton] }) }));
     }
     else if (!isQlPredicateError(root) && isQlGroup(root)) {
-        body = (_jsx(QueryBuilderProvider, { module: props.module, columnScope: props.columnScope, getColumns: props.getColumns, getFields: props.getFields, subject: props.subject, hideInlineAdd: props.hideInlineAdd ?? true, hideAddGroup: props.hideAddGroup, hideLockedSubject: props.hideLockedSubject, hideDragHandles: props.hideDragHandles, layout: props.layout ?? 'auto', children: props.hideDragHandles ? (_jsx(Box, { "data-name": "query-builder2-editor", className: "twa:my-2", children: _jsx(NodeEditor, { node: root, path: [], isRoot: true, dispatch: dispatch }) })) : (_jsx(DragDropProvider, { children: _jsx(Box, { "data-name": "query-builder2-editor", className: "twa:my-2", children: _jsx(NodeEditor, { node: root, path: [], isRoot: true, dispatch: dispatch }) }) })) }));
+        body = (_jsx(QueryBuilderProvider, { module: props.module, columnScope: props.columnScope, getColumns: props.getColumns, getFields: props.getFields, subject: props.subject, hideInlineAdd: props.hideInlineAdd ?? true, hideAddGroup: props.hideAddGroup, hideLockedSubject: props.hideLockedSubject, hideDragHandles: props.hideDragHandles, layout: props.layout ?? 'auto', rootHeaderEnd: props.rootHeaderEnd, children: props.hideDragHandles ? (_jsx(Box, { "data-name": "query-builder2-editor", className: "twa:my-2", children: _jsx(NodeEditor, { node: root, path: [], isRoot: true, dispatch: dispatch }) })) : (_jsx(DragDropProvider, { children: _jsx(Box, { "data-name": "query-builder2-editor", className: "twa:my-2", children: _jsx(NodeEditor, { node: root, path: [], isRoot: true, dispatch: dispatch }) }) })) }));
     }
     return (_jsxs(Box, { className: twMerge(QUERY_BUILDER_CLASSNAME, QUERY_BUILDER_LAYOUT_CLASS[props.layout ?? 'auto']), children: [body, !props.hideExpressionPreview && (_jsxs(Card, { shadow: false, className: "twa:mt-12", children: [_jsxs(Card.Title, { className: "twa:justify-between twa:gap-2", children: [_jsxs(Flex, { flexDirection: "column", className: "twa:min-w-0 twa:gap-0.5", children: [_jsx(Box, { className: "twa:font-medium", children: "Output Expression" }), _jsx(Box, { className: "twa:text-xs twa:opacity-70 twa:font-normal", children: cannotDisplayInQueryBuilder
                                             ? 'Readonly view of the current Expression'

package/src/components/aql/QueryBuilder/QueryBuilderInputs.js

@@ -7,6 +7,7 @@ import * as ModuleConstants from '../../../Utilities/Constants/ModuleConstants';
 import { cn } from '../../../lib/utils';
 import { useAdaptable } from '../../../View/AdaptableContext';
 import AdaptableInput from '../../../View/Components/AdaptableInput';
+import { AdaptableDateInlineInput } from '../../../View/Components/AdaptableInput/AdaptableDateInlineInput';
 import { FloatingFilterValues } from '../../../View/Filter/ColumnFilter/components/FloatingFilterValues';
 import { QueryBuilderColumnSelector } from './QueryBuilderColumnSelector';
 import { FieldSelector } from '../../../View/Components/Selectors/FieldSelector';
@@ -96,7 +97,7 @@ export const PrimitiveColumnOrFieldSelector = (props) => {
         input = (_jsx(Box, { "data-id": "query-input-row-display", "data-name": "qb2-whole-row", "data-slot": "select-trigger", className: subjectPillClassName, children: "Whole Row" }));
     }
     else {
-        input = (_jsx(Box, { "data-id": "query-input-scope-display", "data-slot": "select-trigger", className: subjectPillClassName, children: scopeMeta?.description ?? '$SCOPE' }));
+        input = (_jsx(Box, { "data-id": "query-input-scope-display", "data-slot": "select-trigger", className: subjectPillClassName, children: "Scoped Columns" }));
     }
     const typeOptions = [
         {
@@ -155,8 +156,12 @@ export const PrimitiveColumnOrFieldSelector = (props) => {
 };
 export const PrimitiveValueInput = (props) => {
     const adaptable = useAdaptable();
-    const { layout } = useQueryBuilder();
+    const { layout, module } = useQueryBuilder();
     const isStackedLayout = layout === 'stacked';
+    const showDatePicker = adaptable.api.optionsApi.getFilterOptions().showDatePicker;
+    const useInlineDateInput = !showDatePicker &&
+        (module === ModuleConstants.ColumnFilterModuleId ||
+            module === ModuleConstants.GridFilterModuleId);
     const allowedModes = props.allowedModes ?? DEFAULT_QUERY_BUILDER_INPUT_MODES;
     const hasFields = React.useMemo(() => {
         return adaptable.api.expressionApi.internalApi.getAvailableFields()?.length > 0;
@@ -218,6 +223,11 @@ export const PrimitiveValueInput = (props) => {
                     } }));
             case 'date': {
                 const dateStr = typeof currentLiteralValue === 'string' ? currentLiteralValue : '';
+                if (useInlineDateInput) {
+                    return (_jsx(AdaptableDateInlineInput, { ...common, value: dateStr, onChange: (value) => {
+                            props.onChange(value ? literalOf('date', value) : undefined);
+                        } }));
+                }
                 return (_jsx(AdaptableInput, { ...common, type: "date", value: dateStr, onChange: (event) => {
                         const raw = event.target.value;
                         props.onChange(literalOf('date', raw));