@finos/legend-data-cube 0.0.37 → 0.0.39

package/src/stores/services/DataCubeLogService.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { LogEvent } from '@finos/legend-shared';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+
+export class DataCubeLogService {
+  private readonly _engine: DataCubeEngine;
+
+  constructor(engine: DataCubeEngine) {
+    this._engine = engine;
+  }
+
+  logDebug(message: string, ...data: unknown[]) {
+    this._engine.logDebug(message, ...data);
+  }
+
+  debugProcess(processName: string, ...data: [string, unknown][]) {
+    this._engine.debugProcess(processName, ...data);
+  }
+
+  logInfo(event: LogEvent, ...data: unknown[]) {
+    this._engine.logInfo(event, ...data);
+  }
+
+  logWarning(event: LogEvent, ...data: unknown[]) {
+    this._engine.logWarning(event, ...data);
+  }
+
+  logError(event: LogEvent, ...data: unknown[]) {
+    this._engine.logError(event, ...data);
+  }
+
+  logUnhandledError(error: Error) {
+    this._engine.logUnhandledError(error);
+  }
+
+  logIllegalStateError(message: string, error?: Error) {
+    this._engine.logIllegalStateError(message, error);
+  }
+}

package/src/stores/services/DataCubeNavigationService.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+
+export class DataCubeNavigationService {
+  private readonly _engine: DataCubeEngine;
+
+  constructor(engine: DataCubeEngine) {
+    this._engine = engine;
+  }
+
+  openLink(url: string) {
+    this._engine.openLink(url);
+  }
+}

package/src/stores/{view/DataCubeQuerySnapshotManager.ts → services/DataCubeQuerySnapshotService.ts}

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import type { DataCubeViewState } from './DataCubeViewState.js';
 import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
 import {
   IllegalStateError,
@@ -22,8 +21,11 @@ import {
   deepDiff,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
-import type { DataCubeQuery } from '../core/models/DataCubeQuery.js';
-import { DataCubeSettingKey } from '../core/DataCubeSetting.js';
+import type { DataCubeQuery } from '../core/model/DataCubeQuery.js';
+import { DataCubeSettingKey } from '../../__lib__/DataCubeSetting.js';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+import type { DataCubeSettingService } from './DataCubeSettingService.js';
+import type { DataCubeLogService } from './DataCubeLogService.js';
 
 // TODO: set a stack depth when we implement undo/redo
 // const DATA_CUBE_MAX_SNAPSHOT_COUNT = 100;
@@ -37,40 +39,52 @@ interface DataCubeQuerySnapshotSubscriber {
 export abstract class DataCubeQuerySnapshotController
   implements DataCubeQuerySnapshotSubscriber
 {
-  readonly view!: DataCubeViewState;
+  protected readonly _engine: DataCubeEngine;
+  protected readonly _settingService: DataCubeSettingService;
+  protected readonly _snapshotService: DataCubeQuerySnapshotService;
 
-  private latestSnapshot: DataCubeQuerySnapshot | undefined;
+  private _latestSnapshot: DataCubeQuerySnapshot | undefined;
 
-  constructor(view: DataCubeViewState) {
-    this.view = view;
+  constructor(
+    engine: DataCubeEngine,
+    settingService: DataCubeSettingService,
+    snapshotService: DataCubeQuerySnapshotService,
+  ) {
+    this._engine = engine;
+    this._settingService = settingService;
+    this._snapshotService = snapshotService;
   }
 
   abstract getSnapshotSubscriberName(): string;
 
-  abstract applySnapshot(
-    snapshot: DataCubeQuerySnapshot,
-    previousSnapshot: DataCubeQuerySnapshot | undefined,
-  ): Promise<void>;
+  getLatestSnapshot() {
+    return this._latestSnapshot;
+  }
 
   async receiveSnapshot(snapshot: DataCubeQuerySnapshot) {
-    const previousSnapshot = this.latestSnapshot;
-    this.latestSnapshot = snapshot;
+    const previousSnapshot = this._latestSnapshot;
+    this._latestSnapshot = snapshot;
 
     // NOTE: fully clone the snapshot before applying it to avoid any potential
     // mutation of the snapshot by the subscriber
     await this.applySnapshot(snapshot.INTERNAL__fullClone(), previousSnapshot);
   }
 
+  abstract applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ): Promise<void>;
+
   publishSnapshot(snapshot: DataCubeQuerySnapshot) {
-    const previousSnapshot = this.latestSnapshot;
-    this.latestSnapshot = snapshot;
+    const previousSnapshot = this._latestSnapshot;
+    this._latestSnapshot = snapshot;
 
     if (
-      this.view.dataCube.settings.getBooleanValue(
+      this._settingService.getBooleanValue(
         DataCubeSettingKey.DEBUGGER__ENABLE_DEBUG_MODE,
       )
     ) {
-      this.view.engine.debugProcess(
+      this._engine.debugProcess(
         `New Snapshot`,
         ['Publisher', this.getSnapshotSubscriberName()],
         ['Snapshot', snapshot],
@@ -79,32 +93,30 @@ export abstract class DataCubeQuerySnapshotController
       );
     }
 
-    this.view.snapshotManager.broadcastSnapshot(snapshot);
-  }
-
-  getLatestSnapshot() {
-    return this.latestSnapshot;
+    this._snapshotService.broadcastSnapshot(snapshot);
   }
 }
 
-export class DataCubeQuerySnapshotManager {
-  private readonly view: DataCubeViewState;
-  private readonly subscribers: DataCubeQuerySnapshotSubscriber[] = [];
-  private readonly snapshots: DataCubeQuerySnapshot[] = [];
+export class DataCubeQuerySnapshotService {
+  private readonly _engine: DataCubeEngine;
+  private readonly _logService: DataCubeLogService;
 
+  private readonly _subscribers: DataCubeQuerySnapshotSubscriber[] = [];
+  private readonly _snapshots: DataCubeQuerySnapshot[] = []; // stack
   private _initialSnapshot: DataCubeQuerySnapshot | undefined;
   private _initialQuery: DataCubeQuery | undefined;
 
-  constructor(view: DataCubeViewState) {
-    this.view = view;
+  constructor(engine: DataCubeEngine, logService: DataCubeLogService) {
+    this._engine = engine;
+    this._logService = logService;
   }
 
   get currentSnapshot() {
-    return guaranteeNonNullable(this.snapshots[this.snapshots.length - 1]);
+    return guaranteeNonNullable(this._snapshots[this._snapshots.length - 1]);
   }
 
   registerSubscriber(subscriber: DataCubeQuerySnapshotSubscriber) {
-    const existingSubscriber = this.subscribers.find(
+    const existingSubscriber = this._subscribers.find(
       (sub) =>
         sub.getSnapshotSubscriberName() ===
         subscriber.getSnapshotSubscriberName(),
@@ -112,7 +124,7 @@ export class DataCubeQuerySnapshotManager {
     if (existingSubscriber) {
       // eslint-disable-next-line no-process-env
       if (process.env.NODE_ENV === 'development') {
-        this.view.engine.logDebug(
+        this._logService.logDebug(
           `Subscriber with name '${subscriber.getSnapshotSubscriberName()}' already exists`,
         );
       } else {
@@ -121,7 +133,7 @@ export class DataCubeQuerySnapshotManager {
         );
       }
     }
-    this.subscribers.push(subscriber);
+    this._subscribers.push(subscriber);
   }
 
   initialize(
@@ -153,18 +165,18 @@ export class DataCubeQuerySnapshotManager {
 
   broadcastSnapshot(snapshot: DataCubeQuerySnapshot) {
     if (!snapshot.isFinalized()) {
-      this.view.engine.logIllegalStateError(
+      this._logService.logIllegalStateError(
         `Snapshot must be finalized before broadcasting`,
       );
       return;
     }
-    this.snapshots.push(snapshot);
-    this.subscribers.forEach((subscriber) => {
+    this._snapshots.push(snapshot);
+    this._subscribers.forEach((subscriber) => {
       const currentSnapshot = subscriber.getLatestSnapshot();
       if (currentSnapshot?.uuid !== snapshot.uuid) {
         subscriber.receiveSnapshot(snapshot).catch((error: unknown) => {
           assertErrorThrown(error);
-          this.view.engine.logIllegalStateError(
+          this._logService.logIllegalStateError(
             `Error occured while subscribers receiving and applying new snapshot should be handled gracefully`,
             error,
           );
@@ -172,6 +184,4 @@ export class DataCubeQuerySnapshotManager {
       }
     });
   }
-
-  // TODO: replace snapshot (for minor modifications such as adjusting the cast columns)
 }

package/src/stores/{DataCubeSettings.tsx → services/DataCubeSettingService.tsx}

@@ -14,15 +14,7 @@
  * limitations under the License.
  */
 
-import type { DataCubeState } from './DataCubeState.js';
-import {
-  DataCubeSettingGroup,
-  DataCubeSettingKey,
-  DataCubeSettingType,
-  type DataCubeSetting,
-  type DataCubeSettingValue,
-  type DataCubeSettingValues,
-} from './core/DataCubeSetting.js';
+import { DataCubeSettingKey } from '../../__lib__/DataCubeSetting.js';
 import {
   hashArray,
   IllegalStateError,
@@ -32,8 +24,8 @@ import {
   LogEvent,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { DataCubeEvent } from '../__lib__/DataCubeEvent.js';
-import type { DataCubeOptions } from './DataCubeOptions.js';
+import { DataCubeEvent } from '../../__lib__/DataCubeEvent.js';
+import type { DataCubeOptions } from '../DataCubeOptions.js';
 import {
   action,
   computed,
@@ -41,40 +33,95 @@ import {
   observable,
   runInAction,
 } from 'mobx';
-import type { DisplayState } from './core/DataCubeLayoutManagerState.js';
-import { DataCubeSettingsPanel } from '../components/core/DataCubeSettingsPanel.js';
+import type {
+  DataCubeLayoutService,
+  DisplayState,
+} from './DataCubeLayoutService.js';
+import { DataCubeSettingsPanel } from '../../components/core/DataCubeSettingsPanel.js';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+import type { DataCubeAPI, INTERNAL__DataCubeAPI } from '../DataCubeAPI.js';
+import type { DataCubeLogService } from './DataCubeLogService.js';
+
+export type DataCubeSettingValue =
+  | string
+  | number
+  | boolean
+  | object
+  | undefined;
+
+export type DataCubeSettingValues = {
+  [key: string]: DataCubeSettingValue;
+};
+
+export enum DataCubeSettingGroup {
+  DEBUG = 'Debug',
+  GRID = 'Grid',
+}
+
+export enum DataCubeSettingType {
+  BOOLEAN = 'boolean',
+  NUMERIC = 'numeric',
+  STRING = 'string',
+  ACTION = 'action',
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type DataCubeSetting<T extends DataCubeSettingValue = any> = {
+  key: string;
+  title: string;
+  group: string;
+  type: DataCubeSettingType;
+  defaultValue: T;
+  action?: ((api: DataCubeAPI, newValue: T) => void) | undefined;
+  description?: string | undefined;
+  valueOptional?: boolean | undefined;
+  requiresReload?: boolean | undefined;
+  // numeric value specifics - TODO: we might want to break these downw to separate types
+  numericValueMin?: number | undefined;
+  numericValueMax?: number | undefined;
+  numericValueStep?: number | undefined;
+};
+
+export class DataCubeSettingService {
+  private readonly _engine: DataCubeEngine;
+  private readonly _logService: DataCubeLogService;
+  private readonly _layoutService: DataCubeLayoutService;
+  private readonly _options?: DataCubeOptions | undefined;
 
-export class DataCubeSettings {
-  readonly dataCube: DataCubeState;
   readonly display: DisplayState;
   readonly configurations = new Map<string, DataCubeSetting>();
   readonly defaultValues = new Map<string, DataCubeSettingValue>();
-  readonly defaultValuesHashCode!: string;
+  private readonly _defaultValuesHashCode!: string;
   readonly values = new Map<string, DataCubeSettingValue>();
   readonly currentValues = new Map<string, DataCubeSettingValue>();
 
-  getSettingValues?: (() => DataCubeSettingValues | undefined) | undefined;
-  onSettingValuesChanged?:
-    | ((values: DataCubeSettingValues) => void)
-    | undefined;
-  gridClientLicense?: string | undefined;
-
-  constructor(dataCube: DataCubeState, options?: DataCubeOptions | undefined) {
-    makeObservable(this, {
+  constructor(
+    engine: DataCubeEngine,
+    logService: DataCubeLogService,
+    layoutService: DataCubeLayoutService,
+    options?: DataCubeOptions | undefined,
+  ) {
+    makeObservable<
+      DataCubeSettingService,
+      'valuesHashCode' | 'currentValuesHashCode'
+    >(this, {
       values: observable,
       save: action,
       valuesHashCode: computed,
 
       currentValues: observable,
-      resetDefaultValues: action,
+      restoreDefaultValues: action,
       currentValuesHashCode: computed,
+
+      allowRestoreDefaultValues: computed,
     });
 
-    this.dataCube = dataCube;
-    this.getSettingValues = options?.getSettingValues;
-    this.onSettingValuesChanged = options?.onSettingValuesChanged;
+    this._engine = engine;
+    this._logService = logService;
+    this._layoutService = layoutService;
+    this._options = options;
 
-    this.display = this.dataCube.engine.layout.newDisplay(
+    this.display = this._layoutService.newDisplay(
       'Settings',
       () => <DataCubeSettingsPanel />,
       {
@@ -97,6 +144,15 @@ export class DataCubeSettings {
         type: DataCubeSettingType.BOOLEAN,
         defaultValue: false,
       } satisfies DataCubeSetting<boolean>,
+      {
+        key: DataCubeSettingKey.DEBUGGER__ACTION__RELOAD,
+        title: `Reload`,
+        description: `Manually reload DataCube (keeping all states). This is needed when making changes to settings that require reloading to take effect.`,
+        group: DataCubeSettingGroup.DEBUG,
+        type: DataCubeSettingType.ACTION,
+        action: (api) => api.reload(),
+        defaultValue: undefined,
+      } satisfies DataCubeSetting,
       {
         key: DataCubeSettingKey.GRID_CLIENT__SUPPRESS_LARGE_DATASET_WARNING,
         title: `Large Dataset Warning: Disabled`,
@@ -114,8 +170,8 @@ export class DataCubeSettings {
         defaultValue: 50,
         numericValueMin: 10,
         numericValueStep: 10,
-        action: (newValue) =>
-          this.dataCube.runTaskForEachView((view) => {
+        action: (api, newValue) =>
+          (api as INTERNAL__DataCubeAPI)._runTaskForEachView((view) => {
             view.grid.client.updateGridOptions({
               rowBuffer: newValue,
             });
@@ -128,36 +184,36 @@ export class DataCubeSettings {
         group: DataCubeSettingGroup.GRID,
         type: DataCubeSettingType.BOOLEAN,
         defaultValue: false,
-        action: (newValue) =>
-          this.dataCube.runTaskForEachView((view) => {
+        action: (api, newValue) =>
+          (api as INTERNAL__DataCubeAPI)._runTaskForEachView((view) => {
             view.grid.client.updateGridOptions({
               purgeClosedRowNodes: newValue,
             });
           }),
       } satisfies DataCubeSetting<boolean>,
       {
-        key: DataCubeSettingKey.GRID_CLIENT__ACTION__REFRESH_FAILED_DATA_FETCHES,
-        title: `Refresh Failed Data Fetch: Action`,
+        key: DataCubeSettingKey.GRID_CLIENT__ACTION__RETRY_FAILED_DATA_FETCHES,
+        title: `Retry Failed Data Fetches: Action`,
         description: `Manually re-runs all failed data fetches in the grid.`,
         group: DataCubeSettingGroup.GRID,
         type: DataCubeSettingType.ACTION,
-        action: () => this.dataCube.refreshFailedDataFetches(),
+        action: (api) => api.retryFailedDataFetches(),
         defaultValue: undefined,
       } satisfies DataCubeSetting,
     ];
 
-    [...CORE_SETTINGS, ...(options?.getSettingItems?.() ?? [])].forEach(
-      (configuration) => {
-        this.configurations.set(configuration.key, configuration);
-        this.setValue(configuration.key, configuration.defaultValue, [
-          this.defaultValues,
-          this.values,
-          this.currentValues,
-        ]);
-      },
-    );
+    const { configurations, values } = options?.settingsData ?? {};
+
+    [...CORE_SETTINGS, ...(configurations ?? [])].forEach((configuration) => {
+      this.configurations.set(configuration.key, configuration);
+      this.setValue(configuration.key, configuration.defaultValue, [
+        this.defaultValues,
+        this.values,
+        this.currentValues,
+      ]);
+    });
 
-    const settingValues = this.getSettingValues?.() ?? {};
+    const settingValues = values ?? {};
     Object.keys(settingValues).forEach((key) => {
       const value = settingValues[key];
       // for unknown settings (e.g. outdated settings, settings' keys changed, etc.), we ignore them
@@ -172,7 +228,9 @@ export class DataCubeSettings {
     // be processed here, as they should override the settings retrieved from
     // cache.
 
-    this.defaultValuesHashCode = this.computeValuesHashCode(this.defaultValues);
+    this._defaultValuesHashCode = this.computeValuesHashCode(
+      this.defaultValues,
+    );
   }
 
   private setValue(
@@ -182,7 +240,7 @@ export class DataCubeSettings {
   ) {
     const configuration = this.configurations.get(key);
     if (!configuration) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
         ),
@@ -198,7 +256,7 @@ export class DataCubeSettings {
             (value === undefined && configuration.valueOptional)
           )
         ) {
-          this.dataCube.engine.logWarning(
+          this._logService.logWarning(
             LogEvent.create(
               DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
             ),
@@ -215,7 +273,7 @@ export class DataCubeSettings {
             (value === undefined && configuration.valueOptional)
           )
         ) {
-          this.dataCube.engine.logWarning(
+          this._logService.logWarning(
             LogEvent.create(
               DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
             ),
@@ -232,7 +290,7 @@ export class DataCubeSettings {
             (value === undefined && configuration.valueOptional)
           )
         ) {
-          this.dataCube.engine.logWarning(
+          this._logService.logWarning(
             LogEvent.create(
               DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
             ),
@@ -259,7 +317,7 @@ export class DataCubeSettings {
   private getConfiguration(key: string) {
     const configuration = this.configurations.get(key);
     if (!configuration) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
         ),
@@ -279,7 +337,7 @@ export class DataCubeSettings {
       configuration.type !== DataCubeSettingType.BOOLEAN ||
       !isBoolean(value)
     ) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__RETRIEVE_INCOMPATIBLE_VALUE,
         ),
@@ -299,7 +357,7 @@ export class DataCubeSettings {
       configuration.type !== DataCubeSettingType.NUMERIC ||
       !isNumber(value)
     ) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__RETRIEVE_INCOMPATIBLE_VALUE,
         ),
@@ -316,7 +374,7 @@ export class DataCubeSettings {
     const value = this.values.get(key);
     const configuration = this.getConfiguration(key);
     if (configuration.type !== DataCubeSettingType.STRING || !isString(value)) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__RETRIEVE_INCOMPATIBLE_VALUE,
         ),
@@ -329,29 +387,6 @@ export class DataCubeSettings {
     return value;
   }
 
-  updateValue(key: string, value: DataCubeSettingValue) {
-    const configuration = this.configurations.get(key);
-    if (!configuration) {
-      this.dataCube.engine.logWarning(
-        LogEvent.create(
-          DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
-        ),
-        `Can't set value for unregistered setting '${key}'`,
-      );
-      return;
-    }
-
-    if (!this.setValue(key, value, [this.values, this.currentValues])) {
-      return;
-    }
-
-    // trigger hook
-    this.onSettingValuesChanged?.(this.getCurrentSettingValues());
-
-    // trigger action
-    configuration.action?.(value);
-  }
-
   private computeValuesHashCode(values: Map<string, DataCubeSettingValue>) {
     return hashArray(
       Array.from(values.entries())
@@ -360,22 +395,26 @@ export class DataCubeSettings {
     );
   }
 
-  get valuesHashCode() {
+  private get valuesHashCode() {
     return this.computeValuesHashCode(this.values);
   }
 
-  get currentValuesHashCode() {
+  private get currentValuesHashCode() {
     return this.computeValuesHashCode(this.currentValues);
   }
 
-  resetDefaultValues() {
+  get allowRestoreDefaultValues() {
+    return this._defaultValuesHashCode !== this.currentValuesHashCode;
+  }
+
+  restoreDefaultValues() {
     this.currentValues.clear();
     this.defaultValues.forEach((value, key) =>
       this.currentValues.set(key, value),
     );
   }
 
-  private getCurrentSettingValues(): DataCubeSettingValues {
+  private getCurrentSettingValues() {
     const settingValues: DataCubeSettingValues = {};
     this.values.forEach((value, key) => {
       const configuration = this.configurations.get(key);
@@ -387,7 +426,33 @@ export class DataCubeSettings {
     return settingValues;
   }
 
-  save() {
+  updateValue(api: DataCubeAPI, key: string, value: DataCubeSettingValue) {
+    const configuration = this.configurations.get(key);
+    if (!configuration) {
+      this._logService.logWarning(
+        LogEvent.create(
+          DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
+        ),
+        `Can't set value for unregistered setting '${key}'`,
+      );
+      return;
+    }
+
+    if (!this.setValue(key, value, [this.values, this.currentValues])) {
+      return;
+    }
+
+    // trigger hook
+    this._options?.onSettingsChanged?.({
+      api,
+      values: this.getCurrentSettingValues(),
+    });
+
+    // trigger action
+    configuration.action?.(api, value);
+  }
+
+  save(api: DataCubeAPI) {
     const changedSettingKeys = new Set<string>();
     this.values.forEach((value, key) => {
       if (value !== this.currentValues.get(key)) {
@@ -400,7 +465,10 @@ export class DataCubeSettings {
     this.currentValues.forEach((value, key) => this.values.set(key, value));
 
     // trigger hook
-    this.onSettingValuesChanged?.(this.getCurrentSettingValues());
+    this._options?.onSettingsChanged?.({
+      api,
+      values: this.getCurrentSettingValues(),
+    });
 
     // trigger action
     let requiresReload = false;
@@ -410,12 +478,12 @@ export class DataCubeSettings {
         requiresReload = true;
       }
       if (configuration?.action) {
-        configuration.action(this.values.get(key));
+        configuration.action(api, this.values.get(key));
       }
     }
 
     if (requiresReload) {
-      this.dataCube.reload();
+      api.reload();
     }
   }
 }