@finos/legend-application-repl 0.0.30 → 0.0.32

package/src/stores/dataCube/DataCubeState.ts

@@ -14,32 +14,54 @@
  * limitations under the License.
  */
 
-import type { REPLStore } from './REPLStore.js';
+import type { REPLStore } from '../REPLStore.js';
 import { DataCubeGridState } from './grid/DataCubeGridState.js';
 import { DataCubeEditorState } from './editor/DataCubeEditorState.js';
-import { ActionState, assertErrorThrown } from '@finos/legend-shared';
-import { DataCubeEngine } from './core/DataCubeEngine.js';
+import { assertErrorThrown, uuid } from '@finos/legend-shared';
 import { DataCubeQuerySnapshotManager } from './core/DataCubeQuerySnapshotManager.js';
 import type { LegendREPLApplicationStore } from '../LegendREPLBaseStore.js';
 import { DataCubeCoreState } from './core/DataCubeCoreState.js';
 import { validateAndBuildQuerySnapshot } from './core/DataCubeQuerySnapshotBuilder.js';
+import { action, makeObservable, observable } from 'mobx';
+import type { DataCubeInfrastructure } from './DataCubeInfrastructure.js';
+
+export class DataCubeTask {
+  uuid = uuid();
+  name: string;
+  startTime = Date.now();
+  endTime?: number | undefined;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  end(): void {
+    this.endTime = Date.now();
+  }
+}
 
 export class DataCubeState {
   readonly replStore: REPLStore;
   readonly application: LegendREPLApplicationStore;
-  readonly engine: DataCubeEngine;
+  readonly infrastructure: DataCubeInfrastructure;
   readonly snapshotManager: DataCubeQuerySnapshotManager;
 
   readonly core: DataCubeCoreState;
   readonly grid: DataCubeGridState;
   readonly editor: DataCubeEditorState;
 
-  readonly initState = ActionState.create();
+  readonly runningTasks = new Map<string, DataCubeTask>();
 
   constructor(replStore: REPLStore) {
+    makeObservable(this, {
+      runningTasks: observable,
+      newTask: action,
+      endTask: action,
+    });
+
     this.replStore = replStore;
     this.application = replStore.applicationStore;
-    this.engine = new DataCubeEngine(this.replStore.client);
+    this.infrastructure = replStore.dataCubeInfrastructure;
 
     // NOTE: snapshot manager must be instantiated before subscribers
     this.snapshotManager = new DataCubeQuerySnapshotManager(this);
@@ -48,8 +70,20 @@ export class DataCubeState {
     this.editor = new DataCubeEditorState(this);
   }
 
+  newTask(name: string): DataCubeTask {
+    const task = new DataCubeTask(name);
+    this.runningTasks.set(task.uuid, task);
+    return task;
+  }
+
+  endTask(task: DataCubeTask): DataCubeTask {
+    task.end();
+    this.runningTasks.delete(task.uuid);
+    return task;
+  }
+
   async initialize(): Promise<void> {
-    this.initState.inProgress();
+    const task = this.newTask('Initializing');
     try {
       await Promise.all(
         [this.core, this.editor, this.grid].map(async (state) => {
@@ -57,7 +91,7 @@ export class DataCubeState {
           await state.initialize();
         }),
       );
-      const result = await this.engine.getBaseQuery();
+      const result = await this.infrastructure.engine.getBaseQuery();
       const initialSnapshot = validateAndBuildQuerySnapshot(
         result.partialQuery,
         result.sourceQuery,
@@ -65,11 +99,11 @@ export class DataCubeState {
       );
       initialSnapshot.timestamp = result.timestamp;
       this.snapshotManager.broadcastSnapshot(initialSnapshot);
-      this.initState.complete();
     } catch (error: unknown) {
       assertErrorThrown(error);
       this.application.notificationService.notifyError(error);
-      this.initState.fail();
+    } finally {
+      this.endTask(task);
     }
   }
 }

package/src/stores/dataCube/core/DataCubeConfiguration.ts

@@ -0,0 +1,220 @@
+/**
+ * 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 {
+  DEFAULT_BACKGROUND_COLOR,
+  DEFAULT_ERROR_FOREGROUND_COLOR,
+  DEFAULT_FOREGROUND_COLOR,
+  DEFAULT_NEGATIVE_FOREGROUND_COLOR,
+  DEFAULT_ROW_HIGHLIGHT_BACKGROUND_COLOR,
+  DEFAULT_ZERO_FOREGROUND_COLOR,
+  DEFAULT_GRID_LINE_COLOR,
+  DEFAULT_FONT_FAMILY,
+  DEFAULT_FONT_SIZE,
+  DEFAULT_FONT_BOLD,
+  DEFAULT_FONT_ITALIC,
+  DEFAULT_FONT_STRIKETHROUGH,
+  DEFAULT_TEXT_ALIGN,
+  DEFAULT_FONT_UNDERLINED,
+  DEFAULT_FONT_CASE,
+  DataCubeColumnKind,
+  type DataCubeFont,
+  type DataCubeFontTextAlignment,
+  type DataCubeFontFormatUnderlineVariant,
+  type DataCubeNumberScale,
+  type DataCubeSelectionStat,
+  type DataCubeColumnPinPlacement,
+  type DataCubeFontCase,
+} from './DataCubeQueryEngine.js';
+import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
+import { createModelSchema, list, optional, primitive } from 'serializr';
+
+export type DataCubeConfigurationColorKey =
+  | 'normal'
+  | 'zero'
+  | 'negative'
+  | 'error';
+
+export class DataCubeColumnConfiguration {
+  name: string;
+  type: string;
+
+  kind: DataCubeColumnKind = DataCubeColumnKind.DIMENSION;
+  displayName?: string | undefined;
+
+  decimals?: number | undefined;
+  displayCommas = false;
+  negativeNumberInParens = false;
+  numberScale?: DataCubeNumberScale | undefined;
+
+  hPivotSortFunction?: string | undefined;
+
+  fontFamily?: DataCubeFont | undefined;
+  fontSize?: number | undefined;
+  fontBold?: boolean | undefined;
+  fontItalic?: boolean | undefined;
+  fontUnderline?: DataCubeFontFormatUnderlineVariant | undefined;
+  fontStrikethrough?: boolean | undefined;
+  fontCase?: DataCubeFontCase | undefined;
+  textAlign?: DataCubeFontTextAlignment | undefined;
+  normalForegroundColor?: string | undefined;
+  negativeForegroundColor?: string | undefined;
+  zeroForegroundColor?: string | undefined;
+  errorForegroundColor?: string | undefined;
+  normalBackgroundColor?: string | undefined;
+  negativeBackgroundColor?: string | undefined;
+  zeroBackgroundColor?: string | undefined;
+  errorBackgroundColor?: string | undefined;
+
+  blur = false;
+  hideFromView = false;
+
+  fixedWidth?: number | undefined;
+  minWidth?: number | undefined;
+  maxWidth?: number | undefined;
+  pinned?: DataCubeColumnPinPlacement | undefined;
+  displayAsLink = false;
+  linkLabelParameter?: string | undefined;
+
+  constructor(name: string, type: string) {
+    this.name = name;
+    this.type = type;
+  }
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeColumnConfiguration, {
+      blur: primitive(),
+      decimals: optional(primitive()),
+      displayAsLink: primitive(),
+      displayCommas: primitive(),
+      displayName: optional(primitive()),
+      errorBackgroundColor: optional(primitive()),
+      errorForegroundColor: optional(primitive()),
+      fixedWidth: optional(primitive()),
+      fontBold: optional(primitive()),
+      fontCase: optional(primitive()),
+      fontFamily: optional(primitive()),
+      fontItalic: optional(primitive()),
+      fontSize: optional(primitive()),
+      fontStrikethrough: optional(primitive()),
+      fontUnderline: optional(primitive()),
+      hideFromView: primitive(),
+      hPivotSortFunction: optional(primitive()),
+      kind: primitive(),
+      linkLabelParameter: optional(primitive()),
+      maxWidth: optional(primitive()),
+      minWidth: optional(primitive()),
+      name: primitive(),
+      negativeBackgroundColor: optional(primitive()),
+      negativeForegroundColor: optional(primitive()),
+      normalBackgroundColor: optional(primitive()),
+      normalForegroundColor: optional(primitive()),
+      negativeNumberInParens: primitive(),
+      numberScale: optional(primitive()),
+      pinned: optional(primitive()),
+      textAlign: optional(primitive()),
+      type: primitive(),
+      zeroBackgroundColor: optional(primitive()),
+      zeroForegroundColor: optional(primitive()),
+    }),
+  );
+}
+
+export class DataCubeConfiguration {
+  description?: string | undefined;
+  columns: DataCubeColumnConfiguration[] = [];
+
+  showTreeLines = false;
+  showHorizontalGridLines = false;
+  showVerticalGridLines = true;
+  gridLineColor = DEFAULT_GRID_LINE_COLOR;
+
+  fontFamily = DEFAULT_FONT_FAMILY;
+  fontSize = DEFAULT_FONT_SIZE;
+  fontBold = DEFAULT_FONT_BOLD;
+  fontItalic = DEFAULT_FONT_ITALIC;
+  fontUnderline?: DataCubeFontFormatUnderlineVariant | undefined =
+    DEFAULT_FONT_UNDERLINED;
+  fontStrikethrough = DEFAULT_FONT_STRIKETHROUGH;
+  fontCase?: DataCubeFontCase | undefined = DEFAULT_FONT_CASE;
+  textAlign = DEFAULT_TEXT_ALIGN;
+  normalForegroundColor = DEFAULT_FOREGROUND_COLOR;
+  negativeForegroundColor = DEFAULT_NEGATIVE_FOREGROUND_COLOR;
+  zeroForegroundColor = DEFAULT_ZERO_FOREGROUND_COLOR;
+  errorForegroundColor = DEFAULT_ERROR_FOREGROUND_COLOR;
+  normalBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+  negativeBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+  zeroBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+  errorBackgroundColor = DEFAULT_BACKGROUND_COLOR;
+
+  alternateRows = false;
+  alternateRowsStandardMode = true;
+  alternateRowsColor = DEFAULT_ROW_HIGHLIGHT_BACKGROUND_COLOR;
+  alternateRowsCount = 1;
+
+  // aggregation
+  initialExpandLevel?: number | undefined;
+  showRootAggregation = false;
+  showLeafCount = false;
+  addPivotTotalColumn = true;
+  addPivotTotalColumnOnLeft = true;
+  treeGroupSortFunction?: string | undefined;
+
+  // misc
+  selectionStats: DataCubeSelectionStat[] = [];
+  showWarningForTruncatedResult = true;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeConfiguration, {
+      addPivotTotalColumn: primitive(),
+      addPivotTotalColumnOnLeft: primitive(),
+      alternateRows: primitive(),
+      alternateRowsColor: primitive(),
+      alternateRowsCount: primitive(),
+      alternateRowsStandardMode: primitive(),
+      columns: list(
+        usingModelSchema(DataCubeColumnConfiguration.serialization.schema),
+      ),
+      errorBackgroundColor: primitive(),
+      errorForegroundColor: primitive(),
+      description: optional(primitive()),
+      fontBold: primitive(),
+      fontCase: optional(primitive()),
+      fontFamily: primitive(),
+      fontItalic: primitive(),
+      fontSize: primitive(),
+      fontStrikethrough: primitive(),
+      fontUnderline: optional(primitive()),
+      gridLineColor: primitive(),
+      initialExpandLevel: optional(primitive()),
+      negativeBackgroundColor: primitive(),
+      negativeForegroundColor: primitive(),
+      normalBackgroundColor: primitive(),
+      normalForegroundColor: primitive(),
+      selectionStats: list(primitive()),
+      showHorizontalGridLines: primitive(),
+      showLeafCount: primitive(),
+      showRootAggregation: primitive(),
+      showTreeLines: primitive(),
+      showVerticalGridLines: primitive(),
+      showWarningForTruncatedResult: primitive(),
+      textAlign: primitive(),
+      treeGroupSortFunction: optional(primitive()),
+      zeroBackgroundColor: primitive(),
+      zeroForegroundColor: primitive(),
+    }),
+  );
+}

package/src/stores/dataCube/core/DataCubeConfigurationBuilder.ts

@@ -0,0 +1,60 @@
+/**
+ * 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 { PRIMITIVE_TYPE } from '@finos/legend-graph';
+import {
+  DataCubeColumnConfiguration,
+  DataCubeConfiguration,
+} from './DataCubeConfiguration.js';
+import {
+  DataCubeColumnKind,
+  DataCubeFontTextAlignment,
+} from './DataCubeQueryEngine.js';
+
+export function buildDefaultColumnConfiguration(column: {
+  name: string;
+  type: string;
+}): DataCubeColumnConfiguration {
+  const { name, type } = column;
+  const config = new DataCubeColumnConfiguration(name, type);
+  switch (type) {
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT: {
+      config.kind = DataCubeColumnKind.MEASURE;
+      config.decimals = type === PRIMITIVE_TYPE.INTEGER ? 0 : 2;
+      config.displayCommas = true;
+      config.negativeNumberInParens = true;
+      config.textAlign = DataCubeFontTextAlignment.RIGHT; // always align number to the right
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+  return config;
+}
+
+export function buildDefaultConfiguration(
+  columns: { name: string; type: string }[],
+): DataCubeConfiguration {
+  const configuration = new DataCubeConfiguration();
+  configuration.columns = columns.map((column) =>
+    buildDefaultColumnConfiguration(column),
+  );
+  return configuration;
+}

package/src/stores/dataCube/core/DataCubeCoreState.ts

@@ -18,13 +18,13 @@ import { action, makeObservable, observable } from 'mobx';
 import type { DataCubeState } from '../DataCubeState.js';
 import { DataCubeQuerySnapshotSubscriber } from './DataCubeQuerySnapshotSubscriber.js';
 import type { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
-import { DATA_CUBE_DEFAULT_REPORT_NAME } from '../DataCubeDefaultConfig.js';
 import type { DataCubeQuery } from '../../../server/models/DataCubeQuery.js';
 import { formatDate } from '@finos/legend-shared';
+import { DEFAULT_REPORT_NAME } from './DataCubeQueryEngine.js';
 
 export class DataCubeCoreState extends DataCubeQuerySnapshotSubscriber {
   baseQuery!: DataCubeQuery;
-  name = DATA_CUBE_DEFAULT_REPORT_NAME;
+  name = DEFAULT_REPORT_NAME;
   private startTime?: number | undefined;
 
   constructor(dataCube: DataCubeState) {
@@ -40,14 +40,17 @@ export class DataCubeCoreState extends DataCubeQuerySnapshotSubscriber {
     this.name = val;
   }
 
-  override async applySnapshot(snapshot: DataCubeQuerySnapshot): Promise<void> {
+  override async applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ): Promise<void> {
     const data = snapshot.data;
     this.setName(data.name);
     if (!this.startTime) {
       this.startTime = snapshot.timestamp;
     }
     this.application.layoutService.setWindowTitle(
-      `\u25A6 ${data.name}${this.startTime ? ` - ${formatDate(new Date(this.startTime), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
+      `\u229E ${data.name}${this.startTime ? ` - ${formatDate(new Date(this.startTime), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
     );
   }
 

package/src/stores/dataCube/core/DataCubeQueryBuilder.ts

@@ -51,7 +51,7 @@ import {
   type DataCubeQuerySnapshotFilterCondition,
   type DataCubeQuerySnapshotFilter,
   type DataCubeQuerySnapshot,
-  DataCubeQuerySnapshotSortDirection,
+  DataCubeQuerySnapshotSortOperation,
   DataCubeQuerySnapshotFilterOperation,
   DataCubeQueryFilterGroupOperation,
   _findCol,
@@ -332,6 +332,17 @@ export function buildExecutableQuery(
     funcMap[funcMapKey] = func;
   };
 
+  // --------------------------------- FILTER ---------------------------------
+
+  if (data.filter) {
+    _process(
+      'filter',
+      _function(_name(DataCubeFunction.FILTER), [
+        _lambda([_var()], [_filter(data.filter)]),
+      ]),
+    );
+  }
+
   // --------------------------------- LEAF EXTEND ---------------------------------
 
   if (data.leafExtendedColumns.length) {
@@ -347,13 +358,13 @@ export function buildExecutableQuery(
     );
   }
 
-  // --------------------------------- FILTER ---------------------------------
+  // --------------------------------- SELECT ---------------------------------
 
-  if (data.filter) {
+  if (data.selectColumns.length) {
     _process(
-      'filter',
-      _function(_name(DataCubeFunction.FILTER), [
-        _lambda([_var()], [_filter(data.filter)]),
+      'select',
+      _function(_name(DataCubeFunction.SELECT), [
+        _cols(data.selectColumns.map((col) => _colSpec(col.name))),
       ]),
     );
   }
@@ -398,17 +409,6 @@ export function buildExecutableQuery(
     );
   }
 
-  // --------------------------------- SELECT ---------------------------------
-
-  if (data.selectColumns.length) {
-    _process(
-      'select',
-      _function(_name(DataCubeFunction.SELECT), [
-        _cols(data.selectColumns.map((col) => _colSpec(col.name))),
-      ]),
-    );
-  }
-
   // --------------------------------- SORT ---------------------------------
 
   if (data.sortColumns.length) {
@@ -419,7 +419,7 @@ export function buildExecutableQuery(
           data.sortColumns.map((col) =>
             _function(
               _name(
-                col.direction === DataCubeQuerySnapshotSortDirection.ASCENDING
+                col.operation === DataCubeQuerySnapshotSortOperation.ASCENDING
                   ? DataCubeFunction.ASC
                   : DataCubeFunction.DESC,
               ),

package/src/stores/dataCube/core/DataCubeQueryEngine.ts

@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-import type { V1_AppliedFunction } from '@finos/legend-graph';
+import { TailwindCSSPalette } from '@finos/legend-art';
+import { PRIMITIVE_TYPE, type V1_AppliedFunction } from '@finos/legend-graph';
 
 export enum DataCubeFunction {
   // relation
@@ -62,11 +63,15 @@ export enum DataCubeFunction {
   MAX = 'meta::pure::functions::collection::max',
   MIN = 'meta::pure::functions::collection::min',
   SUM = 'meta::pure::functions::math::sum',
-  STD_DEV_POPULATION = 'meta::pure::functions::math::stdDevPopulation',
-  STD_DEV_SAMPLE = 'meta::pure::functions::math::stdDevSample',
-  UNIQUE_VALUE_ONLY = 'meta::pure::functions::collection::uniqueValueOnly',
+  STDDEV_POP = 'meta::pure::functions::math::stdDevPopulation',
+  STDDEV_SAMP = 'meta::pure::functions::math::stdDevSample',
+  VAR_POP = 'meta::pure::functions::math::variancePopulation',
+  VAR_SAMP = 'meta::pure::functions::math::varianceSample',
+  // UNIQUE_VALUE_ONLY = 'meta::pure::functions::collection::uniqueValueOnly',
+  // PERCENTILE = 'meta::pure::functions::math::percentile',
 }
 
+export const DEFAULT_REPORT_NAME = 'New Report';
 export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
 export const PIVOT_COLUMN_NAME_VALUE_SEPARATOR = '__|__';
 
@@ -74,6 +79,7 @@ export const PIVOT_COLUMN_NAME_VALUE_SEPARATOR = '__|__';
 // when no aggregate is specified in groupBy() or pivot()
 export const INTERNAL__FILLER_COUNT_AGG_COLUMN_NAME =
   'INTERNAL__filler_count_agg_column';
+export const DEFAULT_ROW_BUFFER = 20;
 
 export type DataCubeQueryFunctionMap = {
   leafExtend?: V1_AppliedFunction | undefined;
@@ -88,3 +94,150 @@ export type DataCubeQueryFunctionMap = {
   sort?: V1_AppliedFunction | undefined;
   limit?: V1_AppliedFunction | undefined;
 };
+
+export enum DataCubeNumberScale {
+  BASIS_POINT = 'Basis Points (bp)',
+  PERCENT = 'Percent (%)',
+  THOUSANDS = 'Thousands (k)',
+  MILLIONS = 'Millions (m)',
+  BILLIONS = 'Billions (b)',
+  TRILLIONS = 'Trillions (t)',
+  AUTO = 'Auto (k/m/b/t)',
+}
+
+export enum DataCubeSelectionStat {
+  COUNT = 'Count',
+  SUM = 'Sum',
+  MIN = 'Min',
+  MAX = 'Max',
+  AVERAGE = 'Average',
+}
+
+export enum DataCubeFont {
+  // sans-serif
+  ARIAL = 'Arial',
+  ROBOTO = 'Roboto',
+  ROBOTO_CONDENSED = 'Roboto Condensed',
+
+  // serif
+  TIMES_NEW_ROMAN = 'Times New Roman',
+  GEORGIA = 'Georgia',
+  ROBOTO_SERIF = 'Roboto Serif',
+
+  // monospace
+  JERBRAINS_MONO = 'Jetbrains Mono',
+  ROBOTO_MONO = 'Roboto Mono',
+  UBUNTU_MONO = 'Ubuntu Mono',
+}
+
+export enum DataCubeFontTextAlignment {
+  CENTER = 'center',
+  LEFT = 'left',
+  RIGHT = 'right',
+}
+
+export enum DataCubeFontCase {
+  LOWERCASE = 'lowercase',
+  UPPERCASE = 'uppercase',
+  CAPITALIZE = 'capitalize',
+}
+
+export enum DataCubeFontFormatUnderlineVariant {
+  SOLID = 'solid',
+  DASHED = 'dashed',
+  DOTTED = 'dotted',
+  DOUBLE = 'double',
+  WAVY = 'wavy',
+}
+
+export enum DataCubeColumnKind {
+  MEASURE = 'Measure',
+  DIMENSION = 'Dimension',
+}
+
+export enum DataCubeAggregateFunction {
+  SUM = 'sum',
+  AVERAGE = 'avg',
+  COUNT = 'count',
+  MIN = 'min',
+  MAX = 'max',
+  // UNIQUE = 'uniq',
+  FIRST = 'first',
+  LAST = 'last',
+  MEDIAN = 'median',
+  VAR_POP = 'var_samp',
+  VAR_SAMP = 'var_pop',
+  STDDEV_POP = 'stddev_pop',
+  STDDEV_SAMP = 'stddev_samp',
+  // STANDARD_ERROR = 'stderr',
+  // NULL = 'null',
+  // ssq
+  // countvalid
+  // countnull
+  // uniqunstrict
+  // minmagnitude
+  // maxmagnitude
+  // commonprefix
+  // commonprefixunstrict
+  // strjoin
+  // strjoinuniq
+  // splitjoin
+  // daterange
+  // wavg
+  // wstderr
+  // wsum
+  // custom
+}
+
+export enum DataCubeColumnPinPlacement {
+  LEFT = 'Left',
+  RIGHT = 'Right',
+}
+
+export enum DataCubeColumnDataType {
+  NUMBER = 'number',
+  DATE = 'date',
+  TEXT = 'text',
+}
+
+export function getDataType(type: string): DataCubeColumnDataType {
+  switch (type) {
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT:
+      return DataCubeColumnDataType.NUMBER;
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.DATETIME:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return DataCubeColumnDataType.DATE;
+    case PRIMITIVE_TYPE.STRING:
+    default:
+      return DataCubeColumnDataType.TEXT;
+  }
+}
+
+export const DEFAULT_URL_LABEL_QUERY_PARAM = 'dataCube.linkLabel';
+
+export const DEFAULT_GRID_LINE_COLOR = TailwindCSSPalette.neutral[200];
+export const DEFAULT_ROW_HIGHLIGHT_BACKGROUND_COLOR =
+  TailwindCSSPalette.sky[100];
+
+export const DEFAULT_COLUMN_WIDTH = 300;
+export const DEFAULT_COLUMN_MIN_WIDTH = 50;
+export const DEFAULT_COLUMN_MAX_WIDTH = undefined;
+
+export const DEFAULT_FONT_FAMILY = DataCubeFont.ROBOTO;
+export const DEFAULT_FONT_SIZE = 12;
+export const DEFAULT_FONT_BOLD = false;
+export const DEFAULT_FONT_ITALIC = false;
+export const DEFAULT_FONT_CASE = undefined;
+export const DEFAULT_FONT_UNDERLINED = undefined;
+export const DEFAULT_FONT_STRIKETHROUGH = false;
+export const DEFAULT_TEXT_ALIGN = DataCubeFontTextAlignment.LEFT;
+export const DEFAULT_FOREGROUND_COLOR = TailwindCSSPalette.black;
+export const DEFAULT_BACKGROUND_COLOR = TailwindCSSPalette.transparent;
+export const DEFAULT_ROW_BACKGROUND_COLOR = TailwindCSSPalette.white;
+export const DEFAULT_NEGATIVE_FOREGROUND_COLOR = TailwindCSSPalette.red[500];
+export const DEFAULT_ZERO_FOREGROUND_COLOR = TailwindCSSPalette.neutral[400];
+export const DEFAULT_ERROR_FOREGROUND_COLOR = TailwindCSSPalette.blue[600];