@finos/legend-data-cube 0.0.37 → 0.0.39

package/src/stores/core/filter/DataCubeQueryFilterOperation__NotEqualCaseInsensitiveColumn.tsx

@@ -13,11 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-import { type V1_AppliedFunction } from '@finos/legend-graph';
 import { DataCubeQueryFilterOperation } from './DataCubeQueryFilterOperation.js';
 import type { DataCubeQuerySnapshotFilterCondition } from '../DataCubeQuerySnapshot.js';
-import type { DataCubeColumn } from '../models/DataCubeColumn.js';
+import type { DataCubeColumn } from '../model/DataCubeColumn.js';
 import {
   DataCubeColumnDataType,
   DataCubeFunction,
@@ -35,6 +33,11 @@ import {
   _var,
 } from '../DataCubeQueryBuilderUtils.js';
 import { guaranteeNonNullable, isString } from '@finos/legend-shared';
+import {
+  V1_AppliedProperty,
+  type V1_AppliedFunction,
+} from '@finos/legend-graph';
+import { _buildConditionSnapshotProperty } from '../DataCubeQuerySnapshotBuilderUtils.js';
 
 export class DataCubeQueryFilterOperation__NotEqualCaseInsensitiveColumn extends DataCubeQueryFilterOperation {
   override get label() {
@@ -73,8 +76,19 @@ export class DataCubeQueryFilterOperation__NotEqualCaseInsensitiveColumn extends
   }
 
   buildConditionSnapshot(expression: V1_AppliedFunction) {
-    /** TODO: @datacube roundtrip */
-    return undefined;
+    const value = expression.parameters[1];
+    const filterConditionSnapshot = _buildConditionSnapshotProperty(
+      expression.parameters[0] as V1_AppliedProperty,
+      this.operator,
+    );
+
+    if (value instanceof V1_AppliedProperty) {
+      filterConditionSnapshot.value = {
+        value: value.property,
+        type: DataCubeOperationAdvancedValueType.COLUMN,
+      } satisfies DataCubeOperationValue;
+    }
+    return filterConditionSnapshot satisfies DataCubeQuerySnapshotFilterCondition;
   }
 
   buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {

package/src/stores/core/filter/DataCubeQueryFilterOperation__NotEqualColumn.tsx

@@ -13,11 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-import { type V1_AppliedFunction } from '@finos/legend-graph';
 import { DataCubeQueryFilterOperation } from './DataCubeQueryFilterOperation.js';
 import type { DataCubeQuerySnapshotFilterCondition } from '../DataCubeQuerySnapshot.js';
-import type { DataCubeColumn } from '../models/DataCubeColumn.js';
+import type { DataCubeColumn } from '../model/DataCubeColumn.js';
 import {
   DataCubeColumnDataType,
   DataCubeFunction,
@@ -35,6 +33,11 @@ import {
   _var,
 } from '../DataCubeQueryBuilderUtils.js';
 import { guaranteeNonNullable, isString } from '@finos/legend-shared';
+import {
+  V1_AppliedProperty,
+  type V1_AppliedFunction,
+} from '@finos/legend-graph';
+import { _buildConditionSnapshotProperty } from '../DataCubeQuerySnapshotBuilderUtils.js';
 
 export class DataCubeQueryFilterOperation__NotEqualColumn extends DataCubeQueryFilterOperation {
   override get label() {
@@ -78,8 +81,19 @@ export class DataCubeQueryFilterOperation__NotEqualColumn extends DataCubeQueryF
   }
 
   buildConditionSnapshot(expression: V1_AppliedFunction) {
-    /** TODO: @datacube roundtrip */
-    return undefined;
+    const value = expression.parameters[1];
+    const filterConditionSnapshot = _buildConditionSnapshotProperty(
+      expression.parameters[0] as V1_AppliedProperty,
+      this.operator,
+    );
+
+    if (value instanceof V1_AppliedProperty) {
+      filterConditionSnapshot.value = {
+        value: value.property,
+        type: DataCubeOperationAdvancedValueType.COLUMN,
+      } satisfies DataCubeOperationValue;
+    }
+    return filterConditionSnapshot satisfies DataCubeQuerySnapshotFilterCondition;
   }
 
   buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {

package/src/stores/core/filter/DataCubeQueryFilterOperation__NotStartWith.tsx

@@ -13,14 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-import { type V1_AppliedFunction } from '@finos/legend-graph';
 import {
   DataCubeQueryFilterOperation,
   generateDefaultFilterConditionPrimitiveTypeValue,
 } from './DataCubeQueryFilterOperation.js';
 import type { DataCubeQuerySnapshotFilterCondition } from '../DataCubeQuerySnapshot.js';
-import type { DataCubeColumn } from '../models/DataCubeColumn.js';
+import type { DataCubeColumn } from '../model/DataCubeColumn.js';
 import {
   DataCubeColumnDataType,
   DataCubeFunction,
@@ -36,6 +34,15 @@ import {
   _value,
 } from '../DataCubeQueryBuilderUtils.js';
 import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  V1_PrimitiveValueSpecification,
+  type V1_AppliedFunction,
+  type V1_AppliedProperty,
+} from '@finos/legend-graph';
+import {
+  _buildConditionSnapshotProperty,
+  _dataCubeOperationValue,
+} from '../DataCubeQuerySnapshotBuilderUtils.js';
 
 export class DataCubeQueryFilterOperation__NotStartWith extends DataCubeQueryFilterOperation {
   override get label() {
@@ -74,8 +81,15 @@ export class DataCubeQueryFilterOperation__NotStartWith extends DataCubeQueryFil
   }
 
   buildConditionSnapshot(expression: V1_AppliedFunction) {
-    /** TODO: @datacube roundtrip */
-    return undefined;
+    const value = expression.parameters[1];
+    const filterConditionSnapshot = _buildConditionSnapshotProperty(
+      expression.parameters[0] as V1_AppliedProperty,
+      this.operator,
+    );
+    if (value instanceof V1_PrimitiveValueSpecification) {
+      filterConditionSnapshot.value = _dataCubeOperationValue(value);
+    }
+    return filterConditionSnapshot satisfies DataCubeQuerySnapshotFilterCondition;
   }
 
   buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {

package/src/stores/core/filter/DataCubeQueryFilterOperation__StartWith.tsx

@@ -13,14 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-import { type V1_AppliedFunction } from '@finos/legend-graph';
 import {
   DataCubeQueryFilterOperation,
   generateDefaultFilterConditionPrimitiveTypeValue,
 } from './DataCubeQueryFilterOperation.js';
 import type { DataCubeQuerySnapshotFilterCondition } from '../DataCubeQuerySnapshot.js';
-import type { DataCubeColumn } from '../models/DataCubeColumn.js';
+import type { DataCubeColumn } from '../model/DataCubeColumn.js';
 import {
   DataCubeColumnDataType,
   DataCubeFunction,
@@ -35,6 +33,15 @@ import {
   _value,
 } from '../DataCubeQueryBuilderUtils.js';
 import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  V1_PrimitiveValueSpecification,
+  type V1_AppliedFunction,
+  type V1_AppliedProperty,
+} from '@finos/legend-graph';
+import {
+  _buildConditionSnapshotProperty,
+  _dataCubeOperationValue,
+} from '../DataCubeQuerySnapshotBuilderUtils.js';
 
 export class DataCubeQueryFilterOperation__StartWith extends DataCubeQueryFilterOperation {
   override get label() {
@@ -73,8 +80,15 @@ export class DataCubeQueryFilterOperation__StartWith extends DataCubeQueryFilter
   }
 
   buildConditionSnapshot(expression: V1_AppliedFunction) {
-    /** TODO: @datacube roundtrip */
-    return undefined;
+    const value = expression.parameters[1];
+    const filterConditionSnapshot = _buildConditionSnapshotProperty(
+      expression.parameters[0] as V1_AppliedProperty,
+      this.operator,
+    );
+    if (value instanceof V1_PrimitiveValueSpecification) {
+      filterConditionSnapshot.value = _dataCubeOperationValue(value);
+    }
+    return filterConditionSnapshot satisfies DataCubeQuerySnapshotFilterCondition;
   }
 
   buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {

package/src/stores/core/filter/DataCubeQueryFilterOperation__StartWithCaseInsensitive.tsx

@@ -13,14 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-import { type V1_AppliedFunction } from '@finos/legend-graph';
 import {
   DataCubeQueryFilterOperation,
   generateDefaultFilterConditionPrimitiveTypeValue,
 } from './DataCubeQueryFilterOperation.js';
 import type { DataCubeQuerySnapshotFilterCondition } from '../DataCubeQuerySnapshot.js';
-import type { DataCubeColumn } from '../models/DataCubeColumn.js';
+import type { DataCubeColumn } from '../model/DataCubeColumn.js';
 import {
   DataCubeColumnDataType,
   DataCubeFunction,
@@ -36,6 +34,15 @@ import {
   _var,
 } from '../DataCubeQueryBuilderUtils.js';
 import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  V1_PrimitiveValueSpecification,
+  type V1_AppliedFunction,
+  type V1_AppliedProperty,
+} from '@finos/legend-graph';
+import {
+  _buildConditionSnapshotProperty,
+  _dataCubeOperationValue,
+} from '../DataCubeQuerySnapshotBuilderUtils.js';
 
 export class DataCubeQueryFilterOperation__StartWithCaseInsensitive extends DataCubeQueryFilterOperation {
   override get label() {
@@ -74,8 +81,15 @@ export class DataCubeQueryFilterOperation__StartWithCaseInsensitive extends Data
   }
 
   buildConditionSnapshot(expression: V1_AppliedFunction) {
-    /** TODO: @datacube roundtrip */
-    return undefined;
+    const value = expression.parameters[1];
+    const filterConditionSnapshot = _buildConditionSnapshotProperty(
+      expression.parameters[0] as V1_AppliedProperty,
+      this.operator,
+    );
+    if (value instanceof V1_PrimitiveValueSpecification) {
+      filterConditionSnapshot.value = _dataCubeOperationValue(value);
+    }
+    return filterConditionSnapshot satisfies DataCubeQuerySnapshotFilterCondition;
   }
 
   buildConditionExpression(condition: DataCubeQuerySnapshotFilterCondition) {

package/src/stores/services/DataCubeAlertService.tsx

@@ -0,0 +1,169 @@
+/**
+ * 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 { CODE_EDITOR_LANGUAGE } from '@finos/legend-code-editor';
+import {
+  type DataCubeLayoutService,
+  DEFAULT_ALERT_WINDOW_CONFIG,
+  LayoutConfiguration,
+  WindowState,
+  type WindowConfiguration,
+} from './DataCubeLayoutService.js';
+import { Alert } from '../../components/core/DataCubeAlert.js';
+import type { EngineError } from '@finos/legend-graph';
+import { editor as monacoEditorAPI, Uri } from 'monaco-editor';
+import { DataCubeCodeCheckErrorAlert } from '../../components/core/DataCubeCodeCheckErrorAlert.js';
+import { uuid } from '@finos/legend-shared';
+import type { DataCubeLogService } from './DataCubeLogService.js';
+
+export enum AlertType {
+  ERROR = 'ERROR',
+  INFO = 'INFO',
+  SUCCESS = 'SUCCESS',
+  WARNING = 'WARNING',
+}
+
+export type ActionAlertAction = { label: string; handler: () => void };
+
+export type ActionAlert = {
+  title?: string | undefined;
+  message: string;
+  prompt?: string | undefined;
+  type: AlertType;
+  text?: string | undefined;
+  actions?: ActionAlertAction[] | undefined;
+  onClose?: () => void;
+};
+
+export type ActionAlertOptions = {
+  message: string;
+  text?: string | undefined;
+  actions?: ActionAlertAction[] | undefined;
+  windowTitle?: string | undefined;
+  windowConfig?: WindowConfiguration | undefined;
+};
+
+export class DataCubeAlertService {
+  private readonly _logService: DataCubeLogService;
+  private readonly _layoutService: DataCubeLayoutService;
+
+  constructor(
+    logService: DataCubeLogService,
+    layoutService: DataCubeLayoutService,
+  ) {
+    this._logService = logService;
+    this._layoutService = layoutService;
+  }
+
+  alert(
+    options: ActionAlertOptions & {
+      type: AlertType;
+    },
+  ) {
+    const { message, type, text, actions, windowTitle, windowConfig } = options;
+    const window = new WindowState(
+      new LayoutConfiguration(windowTitle ?? '', () => (
+        <Alert
+          type={type}
+          message={message}
+          text={text}
+          actions={actions}
+          onClose={() => this._layoutService.closeWindow(window)}
+        />
+      )),
+    );
+    window.configuration.window = windowConfig ?? DEFAULT_ALERT_WINDOW_CONFIG;
+    this._layoutService.newWindow(window);
+  }
+
+  alertError(error: Error, options: ActionAlertOptions) {
+    const { message, text, actions, windowTitle, windowConfig } = options;
+    const window = new WindowState(
+      new LayoutConfiguration(windowTitle ?? 'Error', () => (
+        <Alert
+          type={AlertType.ERROR}
+          message={message}
+          text={text}
+          actions={actions}
+        />
+      )),
+    );
+    window.configuration.window = windowConfig ?? DEFAULT_ALERT_WINDOW_CONFIG;
+    this._layoutService.newWindow(window);
+  }
+
+  alertUnhandledError(error: Error) {
+    this._logService.logUnhandledError(error);
+    this.alertError(error, {
+      message: error.message,
+    });
+  }
+
+  alertCodeCheckError(
+    error: EngineError,
+    code: string,
+    codePrefix: string,
+    options: ActionAlertOptions,
+  ) {
+    const { message, text, windowTitle, windowConfig } = options;
+    // correct the source information since we added prefix to the code
+    // and reveal error in the editor
+    if (error.sourceInformation) {
+      error.sourceInformation.startColumn -=
+        error.sourceInformation.startLine === 1 ? codePrefix.length : 0;
+      error.sourceInformation.endColumn -=
+        error.sourceInformation.endLine === 1 ? codePrefix.length : 0;
+      const editorModel = monacoEditorAPI.createModel(
+        code,
+        CODE_EDITOR_LANGUAGE.PURE,
+        Uri.file(`/${uuid()}.pure`),
+      );
+
+      const fullRange = editorModel.getFullModelRange();
+      if (
+        error.sourceInformation.startLine < 1 ||
+        (error.sourceInformation.startLine === 1 &&
+          error.sourceInformation.startColumn < 1) ||
+        error.sourceInformation.endLine > fullRange.endLineNumber ||
+        (error.sourceInformation.endLine === fullRange.endLineNumber &&
+          error.sourceInformation.endColumn > fullRange.endColumn)
+      ) {
+        error.sourceInformation.startColumn = fullRange.startColumn;
+        error.sourceInformation.startLine = fullRange.startLineNumber;
+        error.sourceInformation.endColumn = fullRange.endColumn;
+        error.sourceInformation.endLine = fullRange.endLineNumber;
+      }
+      const window = new WindowState(
+        new LayoutConfiguration(windowTitle ?? 'Error', () => (
+          <DataCubeCodeCheckErrorAlert
+            editorModel={editorModel}
+            error={error}
+            message={message}
+            text={text}
+          />
+        )),
+      );
+      window.configuration.window = windowConfig ?? {
+        width: 500,
+        height: 400,
+        minWidth: 300,
+        minHeight: 300,
+        center: true,
+      };
+      this._layoutService.newWindow(window);
+    }
+  }
+}

package/src/stores/services/DataCubeDocumentationService.tsx

@@ -0,0 +1,74 @@
+/**
+ * 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 { DocumentationEntry } from '@finos/legend-shared';
+import { makeObservable, observable, action } from 'mobx';
+import { DocumentationPanel } from '../../components/core/DataCubeDocumentationPanel.js';
+import type {
+  DataCubeLayoutService,
+  DisplayState,
+} from './DataCubeLayoutService.js';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+
+export class DataCubeDocumentationService {
+  private readonly _engine: DataCubeEngine;
+  private readonly _layoutService: DataCubeLayoutService;
+
+  readonly display: DisplayState;
+
+  currentEntry?: DocumentationEntry | undefined;
+
+  constructor(engine: DataCubeEngine, layoutService: DataCubeLayoutService) {
+    makeObservable(this, {
+      currentEntry: observable,
+      setCurrentEntry: action,
+    });
+
+    this._engine = engine;
+    this._layoutService = layoutService;
+    this.display = this._layoutService.newDisplay(
+      'Documentation',
+      () => <DocumentationPanel />,
+      {
+        x: -50,
+        y: -50,
+        width: 400,
+        height: 400,
+        minWidth: 300,
+        minHeight: 200,
+        center: false,
+      },
+    );
+  }
+
+  getEntry(key: string) {
+    return this._engine.getDocumentationEntry(key);
+  }
+
+  setCurrentEntry(entry: DocumentationEntry | undefined) {
+    this.currentEntry = entry;
+  }
+
+  shouldDisplayDocumentationEntry(entry: DocumentationEntry) {
+    return (
+      /**
+       * Since we're displaying the documentation entry, we want only user-friendly docs
+       * and discard anything that doesn't come with a title, or does not have any content
+       */
+      Boolean(entry.title && (entry.text ?? entry.markdownText))
+    );
+  }
+}

package/src/stores/{core/DataCubeLayoutManagerState.ts → services/DataCubeLayoutService.tsx}

@@ -23,6 +23,13 @@ import {
   runInAction,
 } from 'mobx';
 
+export type WindowSpecification = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
 export type WindowConfiguration = {
   x?: number | undefined;
   y?: number | undefined;
@@ -51,13 +58,21 @@ export class WindowState {
   readonly uuid = uuid();
   readonly configuration: LayoutConfiguration;
   readonly onClose?: (() => void) | undefined;
+  ownerId?: string | undefined;
+  specification?: WindowSpecification | undefined;
 
   constructor(
     configuration: LayoutConfiguration,
     onClose?: (() => void) | undefined,
+    ownerId?: string | undefined,
   ) {
     this.configuration = configuration;
     this.onClose = onClose;
+    this.ownerId = ownerId;
+  }
+
+  setSpecification(val: WindowSpecification) {
+    this.specification = val;
   }
 }
 
@@ -75,7 +90,7 @@ export const DEFAULT_TOOL_PANEL_WINDOW_CONFIG: WindowConfiguration = {
   center: true,
 };
 
-export const DEFAULT_SMALL_ALERT_WINDOW_CONFIG: WindowConfiguration = {
+export const DEFAULT_ALERT_WINDOW_CONFIG: WindowConfiguration = {
   width: 500,
   height: 200,
   minWidth: 200,
@@ -83,23 +98,17 @@ export const DEFAULT_SMALL_ALERT_WINDOW_CONFIG: WindowConfiguration = {
   center: true,
 };
 
-export const DEFAULT_LARGE_ALERT_WINDOW_CONFIG: WindowConfiguration = {
-  width: 600,
-  height: 200,
-  minWidth: 300,
-  minHeight: 150,
-  center: true,
-};
-
 export class DisplayState {
-  private readonly layoutManagerState: LayoutManagerState;
+  private readonly layout: LayoutManager;
   readonly configuration: LayoutConfiguration;
+  readonly ownerId?: string | undefined;
   window?: WindowState | undefined;
 
   constructor(
-    layoutManagerState: LayoutManagerState,
+    layout: LayoutManager,
     title: string,
     contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
+    ownerId?: string | undefined,
   ) {
     makeObservable(this, {
       window: observable,
@@ -108,9 +117,10 @@ export class DisplayState {
       close: action,
     });
 
-    this.layoutManagerState = layoutManagerState;
+    this.layout = layout;
     this.configuration = new LayoutConfiguration(title, contentRenderer);
     this.configuration.window = DEFAULT_TOOL_PANEL_WINDOW_CONFIG;
+    this.ownerId = ownerId;
   }
 
   get isOpen() {
@@ -119,26 +129,30 @@ export class DisplayState {
 
   open() {
     if (this.window) {
-      this.layoutManagerState.bringWindowFront(this.window);
+      this.layout.bringWindowFront(this.window);
     } else {
-      this.window = new WindowState(this.configuration, () =>
-        runInAction(() => {
-          this.window = undefined;
-        }),
+      this.window = new WindowState(
+        this.configuration,
+        () =>
+          runInAction(() => {
+            this.window = undefined;
+          }),
+        this.ownerId,
       );
-      this.layoutManagerState.newWindow(this.window);
+      this.layout.newWindow(this.window, this.ownerId);
     }
   }
 
   close() {
     if (this.window) {
-      this.layoutManagerState.closeWindow(this.window);
+      this.layout.closeWindow(this.window);
       this.window = undefined;
     }
   }
 }
 
-export class LayoutManagerState {
+export class LayoutManager {
+  // TODO?: keep a hashmap, in parallel, for faster lookup
   windows: WindowState[] = [];
 
   constructor() {
@@ -147,6 +161,7 @@ export class LayoutManagerState {
       newWindow: action,
       bringWindowFront: action,
       closeWindow: action,
+      closeWindows: action,
     });
   }
 
@@ -154,15 +169,17 @@ export class LayoutManagerState {
     title: string,
     contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
     windowConfiguration?: WindowConfiguration | undefined,
-  ): DisplayState {
-    const display = new DisplayState(this, title, contentRenderer);
+    ownerId?: string | undefined,
+  ) {
+    const display = new DisplayState(this, title, contentRenderer, ownerId);
     if (windowConfiguration) {
       display.configuration.window = windowConfiguration;
     }
     return display;
   }
 
-  newWindow(window: WindowState) {
+  newWindow(window: WindowState, ownerId?: string | undefined) {
+    window.ownerId = window.ownerId ?? ownerId;
     this.windows.push(window);
   }
 
@@ -181,4 +198,60 @@ export class LayoutManagerState {
       window.onClose?.();
     }
   }
+
+  closeWindows(windows: WindowState[]) {
+    this.windows = this.windows.filter(
+      (window) => !windows.find((w) => w.uuid === window.uuid),
+    );
+    windows.forEach((window) => window.onClose?.());
+  }
+}
+
+export class DataCubeLayoutService {
+  readonly uuid = uuid();
+  readonly manager: LayoutManager;
+
+  constructor(manager?: LayoutManager | undefined) {
+    makeObservable(this, {
+      windows: computed,
+    });
+
+    this.manager = manager ?? new LayoutManager();
+  }
+
+  get windows() {
+    return this.manager.windows.filter(
+      (window) => window.ownerId === this.uuid,
+    );
+  }
+
+  newDisplay(
+    title: string,
+    contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
+    windowConfiguration?: WindowConfiguration | undefined,
+  ) {
+    return this.manager.newDisplay(
+      title,
+      contentRenderer,
+      windowConfiguration,
+      this.uuid,
+    );
+  }
+
+  newWindow(window: WindowState) {
+    this.manager.newWindow(window, this.uuid);
+  }
+
+  bringWindowFront(window: WindowState) {
+    this.manager.bringWindowFront(window);
+  }
+
+  closeWindow(window: WindowState) {
+    this.manager.closeWindow(window);
+  }
+
+  dispose() {
+    // close all windows owned by this service
+    this.manager.closeWindows(this.windows);
+  }
 }