@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/src/new/main/edit-config/shared/datasource-data-base-component.test.ts

@@ -1,568 +0,0 @@
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { SelectRenderer } from '@genesislcap/rapid-grid-pro';
-import { DatasourceInputTypes, actions, selectors } from '../../../store';
-import { Genesis } from '../../../types';
-import {
-  convertToPathFormat,
-  datasourceNameForDisplay,
-  datasourceNameFromDisplay,
-  lookupColumnIsIncluded,
-  mapTypeToRenderer,
-  pathParameters,
-  shouldDisableColumn,
-  configureDisabledColumns,
-} from './datasource-data-base-component.helpers.ts';
-import { GridColumnNames, GridRowData } from './datasource-data-base-component.types';
-
-type TestData = Pick<
-  GridRowData,
-  | GridColumnNames.ColumnName
-  | GridColumnNames.DisplayName
-  | GridColumnNames.Type
-  | GridColumnNames.Datasource
->;
-
-// Helper function to create consistent test data
-function createTestRowData(overrides: Partial<TestData> = {}): TestData {
-  const result: TestData = {
-    [GridColumnNames.ColumnName]: 'testColumn',
-    [GridColumnNames.DisplayName]: 'Test Column',
-    [GridColumnNames.Type]: 'STRING',
-    [GridColumnNames.Datasource]: 'Test (Snapshot)',
-  };
-
-  // Apply overrides properly
-  return { ...result, ...overrides };
-}
-
-// Type for SelectRendererParams
-const FIRST_PARAM = 0 as const;
-export type SelectRendererParams = Parameters<SelectRenderer['init']>[typeof FIRST_PARAM];
-
-// DatasourceNameFromDisplay tests
-const DatasourceNameFromDisplayTests = suite('datasourceNameFromDisplay()');
-
-DatasourceNameFromDisplayTests.before.each(() => {
-  sinon.restore();
-});
-
-DatasourceNameFromDisplayTests(
-  'Correctly builds datasource key from Snapshot (REQ_REP) input',
-  () => {
-    const input = 'myService (Snapshot)';
-    const expected = 'REQ_REP_myService_myService';
-    assert.equal(datasourceNameFromDisplay(input), expected);
-  },
-);
-
-DatasourceNameFromDisplayTests(
-  'Correctly builds datasource key from Data Pipeline (DATA_PIPELINE) input',
-  () => {
-    const input = 'dataFlow (Data Pipeline)';
-    const expected = 'DATA_PIPELINE_dataFlow_dataFlow';
-    assert.equal(datasourceNameFromDisplay(input), expected);
-  },
-);
-
-DatasourceNameFromDisplayTests.run();
-
-// datasourceNameForDisplay tests
-const DatasourceNameForDisplayTests = suite('datasourceNameForDisplay()');
-
-DatasourceNameForDisplayTests('Correctly formats REQ_REP datasource for display', () => {
-  const datasource = 'myService';
-  const type = 'REQ_REP' as DatasourceInputTypes;
-  const expected = 'myService (Snapshot)';
-  assert.equal(datasourceNameForDisplay(datasource, type), expected);
-});
-
-DatasourceNameForDisplayTests('Correctly formats DATA_PIPELINE datasource for display', () => {
-  const datasource = 'dataFlow';
-  const type = 'DATA_PIPELINE' as DatasourceInputTypes;
-  const expected = 'dataFlow (Data Pipeline)';
-  assert.equal(datasourceNameForDisplay(datasource, type), expected);
-});
-
-DatasourceNameForDisplayTests.run();
-
-// LookupColumnIsFiltered tests
-const LookupColumnIsIncluded = suite('lookupColumnIsIncluded');
-
-LookupColumnIsIncluded.before.each(() => {
-  sinon.restore();
-});
-
-LookupColumnIsIncluded('returns true when column is in included', () => {
-  const mockData: TestData = {
-    [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-    [GridColumnNames.ColumnName]: 'testColumn',
-    [GridColumnNames.DisplayName]: 'testColumn',
-    [GridColumnNames.Type]: 'STRING',
-  };
-
-  const mockDatasource = {
-    KEY: 'test',
-    NAME: 'Test Datasource',
-    INPUT_TYPE: 'REQ_REP' as const,
-    OUTPUT_TYPE: 'TABLE' as const,
-    GROUPING_STRATEGY: 'NONE' as const,
-    GROUP_KEY: null,
-    TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
-  };
-
-  sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-  const result = lookupColumnIsIncluded(mockData);
-  assert.equal(result, true);
-});
-
-LookupColumnIsIncluded('returns false when column is not in filters', () => {
-  const mockData: TestData = {
-    [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-    [GridColumnNames.ColumnName]: 'nonFilteredColumn',
-    [GridColumnNames.DisplayName]: 'nonFilteredColumn',
-    [GridColumnNames.Type]: 'STRING',
-  };
-
-  const mockDatasource = {
-    KEY: 'test',
-    NAME: 'Test Datasource',
-    INPUT_TYPE: 'REQ_REP' as const,
-    OUTPUT_TYPE: 'TABLE' as const,
-    GROUPING_STRATEGY: 'NONE' as const,
-    GROUP_KEY: null,
-    TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: ['testColumn', 'otherColumn'] },
-  };
-
-  sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-  const result = lookupColumnIsIncluded(mockData);
-  assert.equal(result, false);
-});
-
-LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is undefined', () => {
-  const mockData: TestData = {
-    [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-    [GridColumnNames.ColumnName]: 'testColumn',
-    [GridColumnNames.DisplayName]: 'testColumn',
-    [GridColumnNames.Type]: 'STRING',
-  };
-
-  const mockDatasource = {
-    KEY: 'test',
-    NAME: 'Test Datasource',
-    INPUT_TYPE: 'REQ_REP' as const,
-    OUTPUT_TYPE: 'TABLE' as const,
-    GROUPING_STRATEGY: 'NONE' as const,
-    GROUP_KEY: null,
-    TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: undefined },
-  };
-
-  sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-  const result = lookupColumnIsIncluded(mockData);
-  assert.equal(result, false);
-});
-
-LookupColumnIsIncluded('returns false when INCLUDE_COLUMNS is empty array', () => {
-  const mockData: TestData = {
-    [GridColumnNames.Datasource]: 'testSource (Snapshot)',
-    [GridColumnNames.ColumnName]: 'testColumn',
-    [GridColumnNames.DisplayName]: 'testColumn',
-    [GridColumnNames.Type]: 'STRING',
-  };
-
-  const mockDatasource = {
-    KEY: 'test',
-    NAME: 'Test Datasource',
-    INPUT_TYPE: 'REQ_REP' as const,
-    OUTPUT_TYPE: 'TABLE' as const,
-    GROUPING_STRATEGY: 'NONE' as const,
-    GROUP_KEY: null,
-    TRANSFORMER_CONFIGURATION: { INCLUDE_COLUMNS: [] },
-  };
-
-  sinon.stub(selectors.datasourceConfig, 'getDatasource').returns(mockDatasource);
-  const result = lookupColumnIsIncluded(mockData);
-  assert.equal(result, false);
-});
-
-LookupColumnIsIncluded.run();
-
-// PathParametersTests tests
-const PathParametersTests = suite('pathParameters()');
-
-// Helper function to build JSON schema for testing
-function buildJsonSchema(properties: any): Genesis.JSONSchema7 {
-  return {
-    type: 'object',
-    properties: properties,
-  };
-}
-
-PathParametersTests('Should convert simple schema properties to grid row data', () => {
-  const datasource: Parameters<typeof pathParameters>[0] = {
-    name: 'TestDatasource',
-    spec: <Genesis.JSONSchema7>{
-      properties: {
-        field1: {
-          genesisType: 'STRING',
-        },
-        field2: {
-          genesisType: 'INT',
-        },
-        field3: {
-          genesisType: 'BOOLEAN',
-        },
-      },
-    },
-  };
-
-  const result = pathParameters(datasource);
-
-  assert.equal(result.length, 3);
-  assert.equal(result[0][GridColumnNames.ColumnName], 'field1');
-  assert.equal(result[0][GridColumnNames.DisplayName], 'field1');
-  assert.equal(result[0][GridColumnNames.Type], 'STRING');
-  assert.equal(result[0][GridColumnNames.Datasource], 'TestDatasource');
-
-  assert.equal(result[1][GridColumnNames.ColumnName], 'field2');
-  assert.equal(result[1][GridColumnNames.Type], 'INT');
-
-  assert.equal(result[2][GridColumnNames.ColumnName], 'field3');
-  assert.equal(result[2][GridColumnNames.Type], 'BOOLEAN');
-});
-
-PathParametersTests('Should handle nullable enum types and extract enum values correctly', () => {
-  // Schema with nullable enum field to test the handling of enum values
-  const datasource: Parameters<typeof pathParameters>[0] = {
-    name: 'TradesData',
-    spec: <Genesis.JSONSchema7>{
-      properties: {
-        TRADE_ID: {
-          type: 'integer',
-          description: '',
-          genesisType: 'LONG',
-        },
-        DIRECTION: {
-          oneOf: [
-            {
-              type: 'null',
-            },
-            {
-              type: 'string',
-              enum: ['SELL', 'SHORT_SELL', 'BUY'],
-            },
-          ],
-          description: '',
-          genesisType: 'ENUM',
-          // No top-level enum property - matches server payload
-        },
-        INSTRUMENT_ID: {
-          oneOf: [
-            {
-              type: 'null',
-            },
-            {
-              type: 'integer',
-            },
-          ],
-          description: '',
-          genesisType: 'LONG',
-        },
-      },
-      additionalProperties: false,
-      required: [],
-    },
-  };
-
-  const result = pathParameters(datasource);
-
-  // Find the DIRECTION field result
-  const directionField = result.find((row) => row[GridColumnNames.ColumnName] === 'DIRECTION');
-
-  assert.ok(directionField, 'DIRECTION field should be in the results');
-  assert.equal(directionField![GridColumnNames.Type], 'ENUM', 'Type should be ENUM');
-
-  // Check that EnumValues array exists and contains the expected values
-  assert.ok(
-    Array.isArray(directionField![GridColumnNames.EnumValues]),
-    'EnumValues should be an array',
-  );
-  assert.equal(
-    directionField![GridColumnNames.EnumValues].length,
-    3,
-    'EnumValues should have 3 items',
-  );
-  assert.equal(directionField![GridColumnNames.EnumValues][0], 'SELL');
-  assert.equal(directionField![GridColumnNames.EnumValues][1], 'SHORT_SELL');
-  assert.equal(directionField![GridColumnNames.EnumValues][2], 'BUY');
-});
-
-PathParametersTests('Should handle non-nullable enum types with top-level enum property', () => {
-  // Schema with non-nullable enum field (direct enum property)
-  const datasource: Parameters<typeof pathParameters>[0] = {
-    name: 'StatusData',
-    spec: <Genesis.JSONSchema7>{
-      properties: {
-        STATUS: {
-          type: 'string',
-          enum: ['ACTIVE', 'PENDING', 'COMPLETED', 'CANCELLED'],
-          description: 'Status field',
-          genesisType: 'ENUM',
-        },
-      },
-      additionalProperties: false,
-      required: [],
-    },
-  };
-
-  const result = pathParameters(datasource);
-
-  // Find the STATUS field result
-  const statusField = result.find((row) => row[GridColumnNames.ColumnName] === 'STATUS');
-
-  assert.ok(statusField, 'STATUS field should be in the results');
-  assert.equal(statusField![GridColumnNames.Type], 'ENUM', 'Type should be ENUM');
-
-  // Check that EnumValues array exists and contains the expected values
-  assert.ok(
-    Array.isArray(statusField![GridColumnNames.EnumValues]),
-    'EnumValues should be an array',
-  );
-  assert.equal(
-    statusField![GridColumnNames.EnumValues].length,
-    4,
-    'EnumValues should have 4 items',
-  );
-  assert.equal(statusField![GridColumnNames.EnumValues][0], 'ACTIVE');
-  assert.equal(statusField![GridColumnNames.EnumValues][1], 'PENDING');
-  assert.equal(statusField![GridColumnNames.EnumValues][2], 'COMPLETED');
-  assert.equal(statusField![GridColumnNames.EnumValues][3], 'CANCELLED');
-});
-
-PathParametersTests('Should throw error for malformed enum schema without enum values', () => {
-  // Schema with malformed enum field (no enum values available)
-  const datasource: Parameters<typeof pathParameters>[0] = {
-    name: 'MalformedData',
-    spec: <Genesis.JSONSchema7>{
-      properties: {
-        BROKEN_ENUM: {
-          description: 'Malformed enum without values',
-          genesisType: 'ENUM',
-          // Missing enum and oneOf - should cause an error
-        },
-      },
-      additionalProperties: false,
-      required: [],
-    },
-  };
-
-  // Should throw an error with specific message
-  assert.throws(
-    () => pathParameters(datasource),
-    Error,
-    "Could not extract enum values for field 'BROKEN_ENUM'",
-  );
-});
-
-PathParametersTests('Should throw error when no properties exist', () => {
-  const datasource = {
-    name: 'TestDatasource',
-    spec: { type: 'object' } as Genesis.JSONSchema7, // Schema without properties
-  };
-
-  assert.throws(
-    () => pathParameters(datasource),
-    Error,
-    'No properties on schema for datasource TestDatasource',
-  );
-});
-
-PathParametersTests('Should handle empty properties object', () => {
-  const datasource = {
-    name: 'TestDatasource',
-    spec: buildJsonSchema({}),
-  };
-
-  assert.equal(pathParameters(datasource), []);
-});
-
-PathParametersTests.run();
-
-// ConvertToPathFormat tests
-const ConvertToPathFormat = suite('convertToPathFormat()');
-
-ConvertToPathFormat('Converts basic string to path format', () => {
-  assert.equal(convertToPathFormat('hello'), '/req-hello');
-});
-
-ConvertToPathFormat('Converts uppercase string to lowercase path format', () => {
-  assert.equal(convertToPathFormat('HELLO'), '/req-hello');
-});
-
-ConvertToPathFormat('Converts string with underscores to dashes', () => {
-  assert.equal(convertToPathFormat('hello_world'), '/req-hello-world');
-});
-
-ConvertToPathFormat('Converts mixed case string with multiple underscores', () => {
-  assert.equal(convertToPathFormat('HELLO_World_TEST'), '/req-hello-world-test');
-});
-
-ConvertToPathFormat('Handles empty string', () => {
-  assert.equal(convertToPathFormat(''), '/req-');
-});
-
-ConvertToPathFormat.run();
-
-// MapTypeToRenderer tests
-const MapTypeToRendererTests = suite('mapTypeToRenderer');
-
-MapTypeToRendererTests('returns "boolean" for boolean type', () => {
-  const result = mapTypeToRenderer('BOOLEAN');
-  assert.equal(result, 'boolean');
-});
-
-MapTypeToRendererTests('returns "string" for string type', () => {
-  const result = mapTypeToRenderer('STRING');
-  assert.equal(result, 'string');
-});
-
-MapTypeToRendererTests('returns "string" for enum type', () => {
-  const result = mapTypeToRenderer('ENUM');
-  assert.equal(result, 'string');
-});
-
-MapTypeToRendererTests('returns "number" for number type', () => {
-  const result = mapTypeToRenderer('LONG');
-  assert.equal(result, 'number');
-});
-
-MapTypeToRendererTests('returns "number" for integer type', () => {
-  const result = mapTypeToRenderer('INT');
-  assert.equal(result, 'number');
-});
-
-MapTypeToRendererTests('returns "number" for DOUBLE type', () => {
-  const result = mapTypeToRenderer('DOUBLE');
-  assert.equal(result, 'number');
-});
-
-MapTypeToRendererTests('returns "number" for SHORT type', () => {
-  const result = mapTypeToRenderer('SHORT');
-  assert.equal(result, 'number');
-});
-
-MapTypeToRendererTests('returns "number" for BIGDECIMAL type', () => {
-  const result = mapTypeToRenderer('BIGDECIMAL');
-  assert.equal(result, 'number');
-});
-
-MapTypeToRendererTests('returns null for unsupported type', () => {
-  const result = mapTypeToRenderer('UNSUPPORTED_TYPE' as any);
-  assert.equal(result, null);
-});
-
-MapTypeToRendererTests.run();
-
-// ShouldDisableColumn tests
-const ShouldDisableColumnTests = suite('shouldDisableColumn()');
-
-ShouldDisableColumnTests.before.each(() => {
-  sinon.restore();
-});
-
-ShouldDisableColumnTests('should return true when Type is undefined', () => {
-  const mockData: Pick<GridRowData, GridColumnNames.Type> = {
-    [GridColumnNames.Type]: undefined as any,
-  };
-
-  const result = shouldDisableColumn(mockData);
-  assert.equal(result, true);
-});
-
-ShouldDisableColumnTests('should return true when Type is RAW', () => {
-  const mockData: Pick<GridRowData, GridColumnNames.Type> = {
-    [GridColumnNames.Type]: 'RAW',
-  };
-
-  const result = shouldDisableColumn(mockData);
-  assert.equal(result, true);
-});
-
-ShouldDisableColumnTests('should return false when Type is valid', () => {
-  const mockData: Pick<GridRowData, GridColumnNames.Type> = {
-    [GridColumnNames.Type]: 'STRING',
-  };
-
-  const result = shouldDisableColumn(mockData);
-  assert.equal(result, false);
-});
-
-ShouldDisableColumnTests.run();
-
-// ConfigureDisabledColumns tests
-const ConfigureDisabledColumnsTests = suite('configureDisabledColumns()');
-
-ConfigureDisabledColumnsTests.before.each(() => {
-  sinon.restore();
-});
-
-ConfigureDisabledColumnsTests('should not set column filter when column type is valid', () => {
-  // Using enum keys now that imports are fixed
-  const mockData: TestData = {
-    [GridColumnNames.ColumnName]: 'testColumn',
-    [GridColumnNames.DisplayName]: 'Test Column',
-    [GridColumnNames.Type]: 'STRING',
-    [GridColumnNames.Datasource]: 'Test (Snapshot)',
-  };
-
-  const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
-  const result = configureDisabledColumns(mockData);
-
-  assert.equal(result, mockData);
-  assert.ok(setColumnIncludedStub.notCalled);
-});
-
-ConfigureDisabledColumnsTests('should set column filter when column type is RAW', () => {
-  const mockData: TestData = {
-    [GridColumnNames.ColumnName]: 'testColumn',
-    [GridColumnNames.DisplayName]: 'Test Column',
-    [GridColumnNames.Type]: 'RAW',
-    [GridColumnNames.Datasource]: 'Test (Snapshot)',
-  };
-
-  const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
-  const result = configureDisabledColumns(mockData);
-
-  assert.equal(result, mockData);
-  assert.ok(setColumnIncludedStub.calledOnce);
-  assert.ok(
-    setColumnIncludedStub.calledWith({
-      key: datasourceNameFromDisplay(mockData[GridColumnNames.Datasource]),
-      column: mockData[GridColumnNames.ColumnName],
-      included: false,
-    }),
-  );
-});
-
-ConfigureDisabledColumnsTests('should set column filter when column type is undefined', () => {
-  const mockData: TestData = {
-    [GridColumnNames.ColumnName]: 'testColumn',
-    [GridColumnNames.DisplayName]: 'Test Column',
-    [GridColumnNames.Type]: undefined as any,
-    [GridColumnNames.Datasource]: 'Test (Snapshot)',
-  };
-
-  const setColumnIncludedStub = sinon.stub(actions.datasourceConfig, 'setColumnIncluded');
-  const result = configureDisabledColumns(mockData);
-
-  assert.equal(result, mockData);
-  assert.ok(setColumnIncludedStub.calledOnce);
-  assert.ok(
-    setColumnIncludedStub.calledWith({
-      key: datasourceNameFromDisplay(mockData[GridColumnNames.Datasource]),
-      column: mockData[GridColumnNames.ColumnName],
-      included: false,
-    }),
-  );
-});
-
-ConfigureDisabledColumnsTests.run();

package/src/new/main/edit-config/shared/datasource-data-base-component.ts

@@ -1,65 +0,0 @@
-import { Connect } from '@genesislcap/foundation-comms';
-import { GenesisElement, observable } from '@genesislcap/web-core';
-import type { JSONSchema7 } from 'json-schema';
-import { getDatasourceSchema } from '../../../utils';
-import { MultiDatasourceHandler } from '../tabbed-datasource-container';
-import { fetchDatasourceSpecs, handleGridError } from './datasource-data-base-component.helpers.ts';
-import { GridRowData } from './datasource-data-base-component.types';
-
-/**
- * Base abstract class for datasource components that handle datasource fields
- * Provides common functionality for data management
- */
-export abstract class DatasourceDataBaseComponent
-  extends GenesisElement
-  implements MultiDatasourceHandler
-{
-  @Connect connect!: Connect;
-
-  @observable fieldData: GridRowData[] = [];
-  @observable dataError = false;
-
-  protected getSchema = getDatasourceSchema(this.connect);
-  protected datasourceSpec: { name: string; spec: JSONSchema7 }[] = [];
-
-  @observable datasourceName: MultiDatasourceHandler['datasourceName'];
-
-  datasourceNameChanged() {
-    this.handleUpdatedDatasources();
-  }
-
-  /**
-   * Updates the datasource specifications based on the selected datasource key
-   */
-  protected async handleUpdatedDatasources() {
-    if (this.datasourceName === null) {
-      this.fieldData = [];
-      return;
-    }
-
-    this.datasourceSpec = await fetchDatasourceSpecs(
-      this.datasourceName,
-      this.getSchema,
-      (error, message) => {
-        this.handleError(error, message);
-      },
-    );
-
-    this.updateDataFields();
-  }
-
-  /**
-   * Transforms the datasource specifications into grid data
-   * Override this method to provide component-specific data transformation
-   */
-  protected abstract updateDataFields(): Promise<void>;
-
-  /**
-   * Common error handler
-   */
-  protected handleError(error: Error, body: string) {
-    handleGridError(error, body);
-    this.dataError = true;
-    this.fieldData = [];
-  }
-}

package/src/new/main/edit-config/shared/datasource-data-base-component.types.ts

@@ -1,55 +0,0 @@
-import { ExpressionBuilderTypes, RuleExpression } from '@genesislcap/foundation-ui';
-import { Genesis } from '../../../types';
-
-/**
- * Comprehensive column names used across all grid components
- */
-export enum GridColumnNames {
-  ColumnName = 'Column Name',
-  DisplayName = 'Display Name',
-  Type = 'Type',
-  Datasource = 'Datasource',
-  Filter = 'Filter',
-  EnumValues = 'Enum Values',
-  DataTransform = 'Data Transform',
-  Format = 'Format',
-}
-
-/**
- * Type for filter values from various sources
- */
-export type FilterValue = (
-  | RuleExpression.StringValue
-  | RuleExpression.BooleanValue
-  | RuleExpression.NumericValue
-)['VALUE'];
-
-/**
- * Comprehensive row data that encompasses all properties across grid components
- * Individual components should use Pick<GridRowData, ...> to select needed fields
- */
-export interface GridRowData {
-  [GridColumnNames.ColumnName]: string;
-  [GridColumnNames.DisplayName]: string;
-  [GridColumnNames.Type]: Genesis.GenesisFieldTypes;
-  [GridColumnNames.Datasource]: string;
-  [GridColumnNames.Filter]?: RuleExpression.Expression['PredicateExpression'];
-  [GridColumnNames.EnumValues]?: string[];
-  [GridColumnNames.DataTransform]?: ExpressionBuilderTypes.ValueConfig;
-  [GridColumnNames.Format]?: string;
-}
-
-/**
- * Invalid column types that should be disabled or filtered
- */
-export const INVALID_COLUMN_TYPES: Genesis.GenesisFieldTypes[] = ['RAW'];
-
-/**
- * Common filter options for row filters
- */
-export const ROW_FILTER_OPERATIONS: RuleExpression.Operation[] = ['NOT_EQUALS', 'EQUALS'];
-
-/**
- * Value for select dropdown that indicates no selection
- */
-export const BLANK_SELECT_OPTION = 'Select option';

package/src/new/main/edit-config/shared/index.ts

@@ -1,3 +0,0 @@
-export * from './datasource-data-base-component.types';
-export * from './datasource-data-base-component.helpers.ts';
-export * from './datasource-data-base-component';

package/src/new/main/edit-config/tabbed-datasource-container/index.ts

@@ -1,2 +0,0 @@
-export * from './tabbed-datasource-container';
-export * from './tabbed-datasource-container.types';