@adaptabletools/adaptable 24.0.0-canary.8 → 24.0.0

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/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/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/env.js

@@ -1,5 +1,5 @@
 export default {
     NEXT_PUBLIC_INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1792792969512 || Date.now(),
-    VERSION: "24.0.0-canary.8" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1793356932854 || Date.now(),
+    VERSION: "24.0.0" || '--current-version--',
 };

package/src/migration/legacyAdaptableQuery.d.ts

@@ -8,16 +8,41 @@ import type { ExpressionKind } from '../AdaptableState/Common/AdaptableQuery';
  * `Report.Query` are renamed to `Expression`.
  */
 export interface LegacyAdaptableQuery {
+    /**
+     * Per-row expression text. Current state stores this string directly on `Rule` or `Expression`.
+     */
     Expression?: string;
+    /**
+     * Aggregated expression text (a brace call). Current state stores the string directly; the kind is inferred.
+     */
     AggregatedExpression?: string;
+    /**
+     * Observable expression text. Current state stores the string directly and treats it as a scalar expression.
+     */
     ObservableExpression?: string;
-    /** @deprecated pre-v24 spelling of `Expression` */
+    /**
+     * Older name for {@link LegacyAdaptableQuery.Expression}.
+     *
+     * @deprecated pre-v24 spelling of `Expression`
+     */
     BooleanExpression?: string;
-    /** @deprecated pre-v24 spelling of `Expression` */
+    /**
+     * Older name for {@link LegacyAdaptableQuery.Expression}.
+     *
+     * @deprecated pre-v24 spelling of `Expression`
+     */
     ScalarExpression?: string;
-    /** @deprecated pre-v24 spelling of `AggregatedExpression` */
+    /**
+     * Older name for {@link LegacyAdaptableQuery.AggregatedExpression}.
+     *
+     * @deprecated pre-v24 spelling of `AggregatedExpression`
+     */
     AggregatedBooleanExpression?: string;
-    /** @deprecated pre-v24 spelling of `AggregatedExpression` */
+    /**
+     * Older name for {@link LegacyAdaptableQuery.AggregatedExpression}.
+     *
+     * @deprecated pre-v24 spelling of `AggregatedExpression`
+     */
     AggregatedScalarExpression?: string;
 }
 /** Either shape a `Rule` / `Query` may have in state being migrated. */