@finos/legend-data-cube 0.0.2

package/src/stores/grid/DataCubeGridQueryBuilder.ts

@@ -0,0 +1,195 @@
+/**
+ * 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,
+  type V1_AppliedFunction,
+  extractElementNameFromPath as _name,
+} from '@finos/legend-graph';
+import { type DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
+import {
+  DataCubeQueryFilterGroupOperator,
+  DataCubeQueryFilterOperator,
+  DataCubeFunction,
+  type DataCubeQueryFunctionMap,
+} from '../core/DataCubeQueryEngine.js';
+import { guaranteeNonNullable, isNullable } from '@finos/legend-shared';
+import {
+  _groupByAggCols,
+  _colSpec,
+  _cols,
+  _filter,
+  _function,
+  _lambda,
+  _var,
+  _functionCompositionUnProcessor,
+} from '../core/DataCubeQueryBuilderUtils.js';
+import {
+  INTERNAL__GRID_CLIENT_MISSING_VALUE,
+  INTERNAL__GRID_CLIENT_ROW_GROUPING_COUNT_AGG_COLUMN_ID,
+} from './DataCubeGridClientEngine.js';
+import type { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+import type { DataCubeQueryFilterOperation } from '../core/filter/DataCubeQueryFilterOperation.js';
+import type { DataCubeQueryAggregateOperation } from '../core/aggregation/DataCubeQueryAggregateOperation.js';
+
+/*****************************************************************************
+ * [GRID]
+ *
+ * These are utilities used to build adhoc executable queries for fetching
+ * data for the grid. The grid comes with features that requires building
+ * slight modifications of the persistent query that would be generated from
+ * the snapshot, such as in the case of pagination, drilldown (group by).
+ *****************************************************************************/
+
+// --------------------------------- BUILDING BLOCKS ---------------------------------
+
+function _rowGroupingCountCol() {
+  const variable = _var();
+  return _colSpec(
+    INTERNAL__GRID_CLIENT_ROW_GROUPING_COUNT_AGG_COLUMN_ID,
+    _lambda([variable], [variable]),
+    _lambda([variable], [_function(DataCubeFunction.COUNT, [variable])]),
+  );
+}
+// --------------------------------- MAIN ---------------------------------
+
+export function generateRowGroupingDrilldownExecutableQueryPostProcessor(
+  drilldownValues: (string | null | undefined)[],
+) {
+  return (
+    snapshot: DataCubeQuerySnapshot,
+    sequence: V1_AppliedFunction[],
+    funcMap: DataCubeQueryFunctionMap,
+    configuration: DataCubeConfiguration,
+    filterOperations: DataCubeQueryFilterOperation[],
+    aggregateOperations: DataCubeQueryAggregateOperation[],
+  ) => {
+    const _unprocess = _functionCompositionUnProcessor(sequence, funcMap);
+    const data = snapshot.data;
+
+    if (funcMap.groupBy) {
+      // --------------------------------- GROUP BY ---------------------------------
+      const groupBy = guaranteeNonNullable(data.groupBy);
+
+      // if any level of drilldown has been done
+      // add a pre-filter to groupBy()
+      if (drilldownValues.length) {
+        sequence.splice(
+          sequence.indexOf(funcMap.groupBy),
+          0,
+          _function(_name(DataCubeFunction.FILTER), [
+            _lambda(
+              [_var()],
+              [
+                _filter(
+                  {
+                    conditions: drilldownValues.map((value, i) => {
+                      const groupByColumn = guaranteeNonNullable(
+                        groupBy.columns[i],
+                      );
+                      if (
+                        isNullable(value) ||
+                        value === INTERNAL__GRID_CLIENT_MISSING_VALUE
+                      ) {
+                        return {
+                          ...groupByColumn,
+                          operation: DataCubeQueryFilterOperator.IS_NULL,
+                          value: undefined,
+                        };
+                      }
+                      const condition = {
+                        ...groupByColumn,
+                        operation: DataCubeQueryFilterOperator.EQUAL,
+                        value: undefined,
+                      };
+                      switch (groupByColumn.type) {
+                        case PRIMITIVE_TYPE.BOOLEAN:
+                          return {
+                            ...condition,
+                            value: {
+                              type: PRIMITIVE_TYPE.BOOLEAN,
+                              value: value === 'true',
+                            },
+                          };
+                        case PRIMITIVE_TYPE.INTEGER:
+                          return {
+                            ...condition,
+                            value: {
+                              type: groupByColumn.type,
+                              value: parseInt(value, 10),
+                            },
+                          };
+                        case PRIMITIVE_TYPE.NUMBER:
+                        case PRIMITIVE_TYPE.DECIMAL:
+                        case PRIMITIVE_TYPE.FLOAT:
+                          return {
+                            ...condition,
+                            value: {
+                              type: groupByColumn.type,
+                              value: parseFloat(value),
+                            },
+                          };
+                        case PRIMITIVE_TYPE.STRING:
+                        case PRIMITIVE_TYPE.DATE:
+                        case PRIMITIVE_TYPE.DATETIME:
+                        case PRIMITIVE_TYPE.STRICTDATE:
+                        case PRIMITIVE_TYPE.STRICTTIME:
+                        default:
+                          return {
+                            ...condition,
+                            value: { type: groupByColumn.type, value },
+                          };
+                      }
+                    }),
+                    groupOperator: DataCubeQueryFilterGroupOperator.AND,
+                  },
+                  filterOperations,
+                ),
+              ],
+            ),
+          ]),
+        );
+      }
+
+      // modify groupBy() based off the current drilldown level
+      if (drilldownValues.length < groupBy.columns.length) {
+        const groupByIdx = sequence.indexOf(funcMap.groupBy);
+        const groupByColumns = groupBy.columns.slice(
+          0,
+          drilldownValues.length + 1,
+        );
+        const groupByFunc = _function(_name(DataCubeFunction.GROUP_BY), [
+          _cols(groupByColumns.map((col) => _colSpec(col.name))),
+          _cols([
+            ..._groupByAggCols(
+              groupByColumns,
+              snapshot,
+              configuration,
+              aggregateOperations,
+            ),
+            _rowGroupingCountCol(), // get the count for each group
+          ]),
+        ]);
+        sequence[groupByIdx] = groupByFunc;
+        funcMap.groupBy = groupByFunc;
+      } else {
+        // when maximum level of drilldown is reached, we simply just need to
+        // filter the data to match drilldown values, no groupBy() is needed.
+        _unprocess('groupBy');
+      }
+    }
+  };
+}

package/src/stores/grid/DataCubeGridQuerySnapshotBuilder.ts

@@ -0,0 +1,125 @@
+/**
+ * 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.
+ */
+
+/***************************************************************************************
+ * [GRID]
+ *
+ * These are utilities used to build the query snapshot from the internal state
+ * of the grid client, AG Grid.
+ ***************************************************************************************/
+
+import type { IServerSideGetRowsRequest } from '@ag-grid-community/core';
+import {
+  _toCol,
+  type DataCubeQuerySnapshot,
+} from '../core/DataCubeQuerySnapshot.js';
+import {
+  GridClientSortDirection,
+  INTERNAL__GRID_CLIENT_TREE_COLUMN_ID,
+} from './DataCubeGridClientEngine.js';
+import {
+  DataCubeQuerySortOperator,
+  getPivotResultColumnBaseColumnName,
+  isPivotResultColumnName,
+} from '../core/DataCubeQueryEngine.js';
+import { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+import { guaranteeNonNullable, uniqBy } from '@finos/legend-shared';
+
+export function getColumnConfiguration(
+  colName: string,
+  configuration: DataCubeConfiguration,
+) {
+  return guaranteeNonNullable(
+    configuration.columns.find((col) => col.name === colName),
+    `Can't find configuration for column '${colName}'`,
+  );
+}
+
+// --------------------------------- MAIN ---------------------------------
+
+export function buildQuerySnapshot(
+  request: IServerSideGetRowsRequest,
+  baseSnapshot: DataCubeQuerySnapshot,
+) {
+  const snapshot = baseSnapshot.clone();
+  const configuration = DataCubeConfiguration.serialization.fromJson(
+    snapshot.data.configuration,
+  );
+
+  // --------------------------------- SELECT ---------------------------------
+
+  snapshot.data.selectColumns = uniqBy(
+    [
+      ...configuration.columns.filter((col) => col.isSelected),
+      ...request.pivotCols.map((col) =>
+        getColumnConfiguration(col.id, configuration),
+      ),
+      ...request.rowGroupCols.map((col) =>
+        getColumnConfiguration(col.id, configuration),
+      ),
+    ],
+    (col) => col.name,
+  ).map(_toCol);
+
+  // --------------------------------- PIVOT ---------------------------------
+
+  snapshot.data.pivot = request.pivotCols.length
+    ? {
+        columns: request.pivotCols.map((col) =>
+          _toCol(getColumnConfiguration(col.id, configuration)),
+        ),
+        castColumns: [],
+      }
+    : undefined;
+
+  // --------------------------------- GROUP BY ---------------------------------
+
+  snapshot.data.groupBy = request.rowGroupCols.length
+    ? {
+        columns: request.rowGroupCols.map((col) =>
+          _toCol(getColumnConfiguration(col.id, configuration)),
+        ),
+      }
+    : undefined;
+
+  // --------------------------------- SORT ---------------------------------
+
+  snapshot.data.sortColumns = request.sortModel
+    // Make sure the tree group is not being sorted since it's a synthetic column
+    // the sorting state of this special column is `synthesized` by ag-grid
+    // so when all group by columns are sorted in the same direction, the tree group
+    // column will be sorted in that direction, and vice versa, when user sorts
+    // the tree-group, all group-by columns will be sorted in that direction
+    .filter((item) => item.colId !== INTERNAL__GRID_CLIENT_TREE_COLUMN_ID)
+    .map((item) => ({
+      ..._toCol(
+        getColumnConfiguration(
+          isPivotResultColumnName(item.colId)
+            ? getPivotResultColumnBaseColumnName(item.colId)
+            : item.colId,
+          configuration,
+        ),
+      ),
+      operation:
+        item.sort === GridClientSortDirection.ASCENDING
+          ? DataCubeQuerySortOperator.ASCENDING
+          : DataCubeQuerySortOperator.DESCENDING,
+    }));
+
+  // --------------------------------- FINALIZE ---------------------------------
+
+  return snapshot;
+}

package/src/stores/grid/DataCubeGridState.ts

@@ -0,0 +1,155 @@
+/**
+ * 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 { guaranteeNonNullable } from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+import type { GridApi } from '@ag-grid-community/core';
+import type { DataCubeViewState } from '../DataCubeViewState.js';
+import {
+  DataCubeGridClientServerSideDataSource,
+  INTERNAL__GRID_CLIENT_DEFAULT_CACHE_BLOCK_SIZE,
+  INTERNAL__GRID_CLIENT_DATA_FETCH_MANUAL_TRIGGER_COLUMN_ID,
+  INTERNAL__GRID_CLIENT_MAX_CACHE_BLOCK_SIZE,
+  INTERNAL__GRID_CLIENT_DEFAULT_ENABLE_PAGINATION,
+  computeHashCodeForDataFetchManualTrigger,
+} from './DataCubeGridClientEngine.js';
+import { DataCubeQuerySnapshotController } from '../core/DataCubeQuerySnapshotManager.js';
+import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
+import { generateGridOptionsFromSnapshot } from './DataCubeGridConfigurationBuilder.js';
+import { DataCubeConfiguration } from '../core/DataCubeConfiguration.js';
+import { DataCubeGridControllerState } from './DataCubeGridControllerState.js';
+import { DataCubeGridClientExportEngine } from './DataCubeGridClientExportEngine.js';
+
+/**
+ * This query editor state is responsible for syncing the internal state of ag-grid
+ * server-side row model data source with the data cube query state. When new snapshot
+ * is published, this editor will translate parts of the snapshot into ag-grid grid
+ * configuration to update; on the other hand, when the grid is interacted with in a way
+ * that impacts the data state of the server-side row model datasource (e.g. filter, sort
+ * pivot, etc.), getRows() is called, a new snapshot is published.
+ * See https://www.ag-grid.com/javascript-data-grid/server-side-model-datasource/#implementing-the-server-side-datasource
+ *
+ * NOTE: The server-side row model data source state is not 1-1 with data cube query state
+ * so we need the {@link DataCubeGridControllerState} to bridge this gap. For example,
+ * interactions like column pinning, column resizing, etc. are not handled by server-side
+ * row model datasource, so without the companion grid controller, these changes will not
+ * trigger publishing a new snapshot, hence not propagated.
+ */
+export class DataCubeGridState extends DataCubeQuerySnapshotController {
+  readonly controller!: DataCubeGridControllerState;
+  readonly exportEngine!: DataCubeGridClientExportEngine;
+  private _client?: GridApi | undefined;
+
+  clientDataSource: DataCubeGridClientServerSideDataSource;
+
+  queryConfiguration: DataCubeConfiguration;
+  rowLimit?: number | undefined;
+  isPaginationEnabled = INTERNAL__GRID_CLIENT_DEFAULT_ENABLE_PAGINATION;
+  scrollHintText?: string | undefined;
+
+  constructor(view: DataCubeViewState) {
+    super(view);
+
+    makeObservable(this, {
+      clientDataSource: observable,
+
+      queryConfiguration: observable,
+
+      rowLimit: observable,
+
+      isPaginationEnabled: observable,
+      setPaginationEnabled: action,
+
+      scrollHintText: observable,
+      setScrollHintText: action,
+
+      applySnapshot: action,
+    });
+
+    this.controller = new DataCubeGridControllerState(this.view);
+    this.exportEngine = new DataCubeGridClientExportEngine(this);
+    this.queryConfiguration = new DataCubeConfiguration();
+    this.clientDataSource = new DataCubeGridClientServerSideDataSource(this);
+  }
+
+  setPaginationEnabled(val: boolean) {
+    this.isPaginationEnabled = val;
+
+    // hard reset the grid, this will force the grid to fetch data again
+    // NOTE: if we don't fully reset the datasource, and say we just turned on pagination,
+    // for how many page that we loaded when pagination is off, the datasource
+    // will fire that many data fetch operations which is expensive.
+    this.clientDataSource = new DataCubeGridClientServerSideDataSource(this);
+    // NOTE: ag-grid uses the cache block size as page size, so it's important to set this
+    // in corresponding to the pagination setting, else it would cause unexpected scrolling behavior
+    this.client.updateGridOptions({
+      cacheBlockSize: val
+        ? INTERNAL__GRID_CLIENT_DEFAULT_CACHE_BLOCK_SIZE
+        : INTERNAL__GRID_CLIENT_MAX_CACHE_BLOCK_SIZE,
+    });
+  }
+
+  setScrollHintText(val: string | undefined) {
+    this.scrollHintText = val;
+  }
+
+  get client() {
+    return guaranteeNonNullable(this._client, 'Grid client is not configured');
+  }
+
+  configureClient(val: GridApi | undefined) {
+    this._client = val;
+  }
+
+  override async applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ) {
+    const queryConfiguration = DataCubeConfiguration.serialization.fromJson(
+      snapshot.data.configuration,
+    );
+    this.queryConfiguration = queryConfiguration;
+    this.rowLimit = snapshot.data.limit;
+
+    const gridOptions = generateGridOptionsFromSnapshot(
+      snapshot,
+      queryConfiguration,
+      this.view,
+    );
+    this.client.updateGridOptions({
+      ...gridOptions,
+      // NOTE: ag-grid uses the cache block size as page size, so it's important to set this
+      // in corresponding to the pagination setting, else it would cause unexpected scrolling behavior
+      cacheBlockSize: this.isPaginationEnabled
+        ? INTERNAL__GRID_CLIENT_DEFAULT_CACHE_BLOCK_SIZE
+        : INTERNAL__GRID_CLIENT_MAX_CACHE_BLOCK_SIZE,
+    });
+
+    // NOTE: when there are changes that affect the data query specification but cannot be captured
+    // in the grid client options, we will need to manually trigger data fetching by updating the
+    // following hash code which is computed from those parts of the new snapshot then making use of
+    // the filter configuration mechanism to trigger getRows() method of server-side row model data source
+    this.client.setFilterModel({
+      [INTERNAL__GRID_CLIENT_DATA_FETCH_MANUAL_TRIGGER_COLUMN_ID]: {
+        type: 'equals',
+        filter: computeHashCodeForDataFetchManualTrigger(
+          snapshot,
+          queryConfiguration,
+        ),
+      },
+    });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,164 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext",
+      "webworker",
+      "scripthost"
+    ],
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "nodenext",
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./lib",
+    "tsBuildInfoFile": "./build/prod.tsbuildinfo",
+    "rootDir": "./src",
+    "jsx": "react-jsx",
+    "moduleResolution": "nodenext",
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "preserveConstEnums": true,
+    "incremental": true,
+    "useDefineForClassFields": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "strictBuiltinIteratorReturn": true,
+    "alwaysStrict": true,
+    "useUnknownInCatchVariables": true
+  },
+  "references": [
+    {
+      "path": "./tsconfig.package.json"
+    }
+  ],
+  "files": [
+    "./src/application/DataCubeDocumentation.ts",
+    "./src/stores/DataCubeViewState.ts",
+    "./src/stores/core/DataCubeConfiguration.ts",
+    "./src/stores/core/DataCubeConfigurationBuilder.ts",
+    "./src/stores/core/DataCubeInfoState.ts",
+    "./src/stores/core/DataCubeQueryBuilder.ts",
+    "./src/stores/core/DataCubeQueryBuilderUtils.ts",
+    "./src/stores/core/DataCubeQueryEngine.ts",
+    "./src/stores/core/DataCubeQuerySnapshot.ts",
+    "./src/stores/core/DataCubeQuerySnapshotBuilder.ts",
+    "./src/stores/core/DataCubeQuerySnapshotBuilderUtils.ts",
+    "./src/stores/core/DataCubeQuerySnapshotManager.ts",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation.ts",
+    "./src/stores/core/filter/DataCubeQueryFilterEditorState.ts",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation.ts",
+    "./src/stores/editor/DataCubeEditorColumnPropertiesPanelState.ts",
+    "./src/stores/editor/DataCubeEditorColumnsPanelState.ts",
+    "./src/stores/editor/DataCubeEditorColumnsSelectorState.ts",
+    "./src/stores/editor/DataCubeEditorGeneralPropertiesPanelState.ts",
+    "./src/stores/editor/DataCubeEditorHorizontalPivotsPanelState.ts",
+    "./src/stores/editor/DataCubeEditorMutableConfiguration.ts",
+    "./src/stores/editor/DataCubeEditorPanelState.ts",
+    "./src/stores/editor/DataCubeEditorSortsPanelState.ts",
+    "./src/stores/editor/DataCubeEditorVerticalPivotsPanelState.ts",
+    "./src/stores/engine/DataCubeEngine.ts",
+    "./src/stores/engine/DataCubeLayoutManagerState.ts",
+    "./src/stores/engine/DataCubeQuery.ts",
+    "./src/stores/grid/DataCubeGridClientEngine.ts",
+    "./src/stores/grid/DataCubeGridClientExportEngine.ts",
+    "./src/stores/grid/DataCubeGridControllerState.ts",
+    "./src/stores/grid/DataCubeGridQueryBuilder.ts",
+    "./src/stores/grid/DataCubeGridQuerySnapshotBuilder.ts",
+    "./src/stores/grid/DataCubeGridState.ts",
+    "./src/index.tsx",
+    "./src/components/DataCube.tsx",
+    "./src/components/DataCubeProvider.tsx",
+    "./src/components/application/DataCubeAlert.tsx",
+    "./src/components/application/DataCubeDocumentationPanel.tsx",
+    "./src/components/application/DataCubeLayoutManager.tsx",
+    "./src/components/application/DataCubeSettingsPanel.tsx",
+    "./src/components/editor/DataCubeEditor.tsx",
+    "./src/components/editor/DataCubeEditorColumnPropertiesPanel.tsx",
+    "./src/components/editor/DataCubeEditorColumnsPanel.tsx",
+    "./src/components/editor/DataCubeEditorColumnsSelector.tsx",
+    "./src/components/editor/DataCubeEditorGeneralPropertiesPanel.tsx",
+    "./src/components/editor/DataCubeEditorHorizontalPivotsPanel.tsx",
+    "./src/components/editor/DataCubeEditorSortsPanel.tsx",
+    "./src/components/editor/DataCubeEditorVerticalPivotsPanel.tsx",
+    "./src/components/extend/DataCubeColumnEditor.tsx",
+    "./src/components/filter/DataCubeFilterEditor.tsx",
+    "./src/components/grid/DataCubeGrid.tsx",
+    "./src/components/grid/DataCubeGridShared.tsx",
+    "./src/components/shared/DataCubeFormUtils.tsx",
+    "./src/components/shared/DataCubePureCodeEditorUtils.tsx",
+    "./src/stores/DataCubeState.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__Average.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__Count.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__First.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__JoinStrings.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__Last.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__Max.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__Min.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__StdDevPopulation.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__StdDevSample.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__Sum.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__UniqueValue.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__VariancePopulation.tsx",
+    "./src/stores/core/aggregation/DataCubeQueryAggregateOperation__VarianceSample.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__Contain.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__ContainCaseInsensitive.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__EndWith.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__EndWithCaseInsensitive.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__Equal.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__EqualCaseInsensitive.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__EqualCaseInsensitiveColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__EqualColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__GreaterThan.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__GreaterThanColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__GreaterThanOrEqual.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__GreaterThanOrEqualColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__IsNotNull.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__IsNull.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__LessThan.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__LessThanColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__LessThanOrEqual.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__LessThanOrEqualColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__NotContain.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__NotEndWith.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__NotEqual.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__NotEqualCaseInsensitive.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__NotEqualCaseInsensitiveColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__NotEqualColumn.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__NotStartWith.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__StartWith.tsx",
+    "./src/stores/core/filter/DataCubeQueryFilterOperation__StartWithCaseInsensitive.tsx",
+    "./src/stores/editor/DataCubeEditorState.tsx",
+    "./src/stores/engine/DataCubeApplicationEngine.tsx",
+    "./src/stores/extend/DataCubeColumnEditorState.tsx",
+    "./src/stores/extend/DataCubeExtendManagerState.tsx",
+    "./src/stores/filter/DataCubeFilterEditorState.tsx",
+    "./src/stores/grid/DataCubeGridConfigurationBuilder.tsx",
+    "./src/stores/grid/DataCubeGridMenuBuilder.tsx"
+  ],
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "src/**/*.json"
+  ],
+  "exclude": [
+    "src/**/__tests__/**/*.*",
+    "src/**/__mocks__/**/*.*"
+  ]
+}