@genesislcap/pbc-reporting-ui 15.19.0 → 15.19.1

package/src/new/styles/misc.styles.ts

@@ -1,25 +0,0 @@
-import { errorColor } from '@genesislcap/rapid-design-system';
-import { css, neutralForegroundRest, neutralLayer4 } from '@genesislcap/web-core';
-
-export const errorMessageStyles = css`
-  .error-message {
-    color: ${neutralForegroundRest};
-    background-color: ${neutralLayer4};
-    border-color: ${errorColor};
-    border-radius: 7px;
-    border-style: solid;
-    border-width: 4px;
-    padding: 5px;
-    margin: 15px;
-    text-align: center;
-    width: fit-content;
-  }
-`;
-
-export const mixinScreen = (display: string = 'block') => `
-  contain: content;
-  display: ${display};
-  height: 100%;
-  width: 100%;
-  overflow-y: auto;
-`;

package/src/new/types/display.ts

@@ -1,4 +0,0 @@
-export namespace Display {
-  export const datasourceInputs = ['Snapshot', 'Data Pipeline'] as const;
-  export type DatasourceInputTypes = (typeof datasourceInputs)[number];
-}

package/src/new/types/index.ts

@@ -1,4 +0,0 @@
-export * from './display';
-export * from './misc';
-export * from './redux';
-export * from './rights';

package/src/new/types/misc.ts

@@ -1,73 +0,0 @@
-import type { JSONSchema7 as JSONShemaBase } from 'json-schema';
-import type {
-  BaseConfig,
-  DatasourceConfig,
-  DatasourceName,
-  Schedule,
-  DatasourceGrouping,
-} from '../store';
-
-export namespace Genesis {
-  export const genesisFieldTypes = [
-    'STRING',
-    'ENUM',
-    'INT',
-    'SHORT',
-    'DOUBLE',
-    'LONG',
-    'BOOLEAN',
-    'BIGDECIMAL',
-    'DATE',
-    'DATETIME',
-    'RAW',
-    'NANO_TIMESTAMP',
-  ] as const;
-
-  export type GenesisFieldTypes = (typeof genesisFieldTypes)[number];
-
-  export type JSONSchema7 = JSONShemaBase & {
-    properties?:
-      | {
-          [key: string]: JSONShemaBase & { genesisType: GenesisFieldTypes };
-        }
-      | undefined;
-  };
-
-  export type ServerReportConfig = Omit<BaseConfig, 'SCHEDULE'> & {
-    DATA_SOURCES: (Omit<DatasourceConfig[DatasourceName], 'GROUPING_STRATEGY' | 'GROUP_KEY'> &
-      (Exclude<DatasourceGrouping, { GROUPING_STRATEGY: 'NONE' }> | {}))[];
-    SCHEDULES: Schedule[];
-  };
-
-  export const FileStorageFields = {
-    FILE_STORAGE_ID: 'FILE_STORAGE_ID',
-    STORAGE_MANAGER: 'STORAGE_MANAGER',
-    FILE_NAME: 'FILE_NAME',
-    FILE_SIZE: 'FILE_SIZE',
-    MODIFIED_AT: 'MODIFIED_AT',
-    MODIFIED_BY: 'MODIFIED_BY',
-    CREATED_BY: 'CREATED_BY',
-    CREATED_AT: 'CREATED_AT',
-    FILE_TYPE: 'FILE_TYPE',
-  } as const;
-
-  export enum FileMetaType {
-    'USER_DOCUMENT' = 'USER_DOCUMENT',
-    'DOCUMENT_TEMPLATE' = 'DOCUMENT_TEMPLATE',
-    'TEMPLATE_ASSET' = 'TEMPLATE_ASSET',
-  }
-
-  export type FileStorageDataRow = {
-    [FileStorageFields.FILE_STORAGE_ID]: string;
-    [FileStorageFields.STORAGE_MANAGER]: string;
-    [FileStorageFields.FILE_NAME]: string;
-    [FileStorageFields.FILE_SIZE]: number;
-    [FileStorageFields.MODIFIED_AT]: number;
-    [FileStorageFields.MODIFIED_BY]: string;
-    [FileStorageFields.CREATED_BY]: string;
-    [FileStorageFields.CREATED_AT]: number;
-    [FileStorageFields.FILE_TYPE]: FileMetaType;
-  };
-}
-
-export type Result<L, R> = { k: 'ok'; info?: L } | { k: 'err'; info?: R };

package/src/new/types/redux.ts

@@ -1,73 +0,0 @@
-import { PayloadAction, Action, Reducer, ReducersMapObject } from '@reduxjs/toolkit';
-
-export type PayloadStateUpdater<T> = PayloadAction<
-  Exclude<
-    {
-      [K in keyof T]: {
-        key: K;
-        value: NonNullable<T[K]>;
-      };
-    }[keyof T],
-    undefined
-  >
->;
-
-type RemoveFirstParam<T> = T extends (first: any, ...args: infer P) => infer R
-  ? (...args: P) => R
-  : never;
-
-export type SelectorWithoutState<T> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? RemoveFirstParam<T[K]> : T[K];
-};
-
-export interface Slice<State = any> {
-  name: string;
-  reducer: Reducer<State, Action>;
-  actions: Record<string, (payload: any) => Action>;
-  selectors: Record<string, (...args: any[]) => any>;
-}
-
-export type SliceArray = Slice[];
-
-export type RootStateFromSlices<S extends SliceArray> = {
-  [K in S[number]['name']]: Extract<S[number], { name: K }> extends Slice<infer State>
-    ? State
-    : never;
-};
-
-type FirstParameter<T> = T extends (...args: infer P) => any ? P[0] : never;
-
-export type ActionsFromSlices<S extends SliceArray> = {
-  [K in S[number]['name']]: {
-    [ActionKey in keyof Extract<S[number], { name: K }>['actions']]: (
-      payload: FirstParameter<Extract<S[number], { name: K }>['actions'][ActionKey]>,
-    ) => void;
-  };
-};
-
-type RemoveFirstParameter<T> = T extends (arg1: any, ...rest: infer Rest) => any ? Rest : never;
-
-export type SelectorsFromSlices<S extends SliceArray> = {
-  [K in S[number]['name']]: {
-    [SelectorKey in keyof Extract<S[number], { name: K }>['selectors']]: (
-      ...payload: RemoveFirstParameter<Extract<S[number], { name: K }>['selectors'][SelectorKey]>
-    ) => ReturnType<Extract<S[number], { name: K }>['selectors'][SelectorKey]> extends void
-      ? any
-      : ReturnType<Extract<S[number], { name: K }>['selectors'][SelectorKey]>;
-  };
-};
-
-export type StoreReturn<S extends SliceArray> = {
-  store: RootStateFromSlices<S>;
-  actions: ActionsFromSlices<S>;
-  selectors: SelectorsFromSlices<S>;
-  rootReducer: ReducersMapObject<RootStateFromSlices<S>>;
-  subscribeKey: (
-    checkerFn: (s: RootStateFromSlices<S>) => string,
-    callbackFn: (s: RootStateFromSlices<S>) => void,
-  ) => void;
-  dispatch: (action: Action) => void;
-  notify: (sliceName: keyof RootStateFromSlices<S>) => void;
-  subscribe: (cb: (state: RootStateFromSlices<S>) => void) => () => void;
-  getState: () => RootStateFromSlices<S>;
-};

package/src/new/types/rights.ts

@@ -1,28 +0,0 @@
-export enum Permissions {
-  // Allows you to view reports, but not delete, edit, or create them. You are allowed to look at the configs themselves
-  ReportConfigurationView = 'ReportConfigurationView',
-
-  // Allows you to create and edit report configs.
-  ReportConfigurationUpdate = 'ReportConfigurationUpdate',
-
-  // Allows you to delete report configs.
-  ReportConfigurationDelete = 'ReportConfigurationDelete',
-
-  // View report destinations, but not delete, edit, or create them. If the user has EditReportConfigs but not ViewReportDestinations then they can't select them when configuring a report
-  ReportDestinationView = 'ReportDestinationView',
-
-  // Allows you to create and edit report destinations
-  ReportDestinationUpdate = 'ReportDestinationUpdate',
-
-  // Allows you to delete report destinations
-  ReportDestinationDelete = 'ReportDestinationDelete',
-
-  // Allows you to execute an existing report config, and view generated reports (even if ViewReport isn't set)
-  ReportRun = 'ReportRun',
-
-  // Allows you to view generated reports
-  ReportView = 'ReportView',
-
-  // Allows you to delete generated reports
-  ReportDelete = 'ReportDelete',
-}

package/src/new/utils/alias-generator.test.ts

@@ -1,44 +0,0 @@
-import { assert, suite } from '@genesislcap/foundation-testing';
-import { generateUniqueAlias } from './alias-generator';
-
-const GenerateUniqueAlias = suite('generateUniqueAlias');
-
-GenerateUniqueAlias('returns the base alias if it does not exist', () => {
-  const existingAliases = new Set(['other']);
-  const alias = generateUniqueAlias('test', existingAliases);
-  assert.equal(alias, 'test');
-});
-
-GenerateUniqueAlias('increments the alias if it already exists', () => {
-  const existingAliases = new Set(['test']);
-  const alias = generateUniqueAlias('test', existingAliases);
-  assert.equal(alias, 'test_1');
-});
-
-GenerateUniqueAlias('increments the alias until it is unique', () => {
-  const existingAliases = new Set(['test', 'test_1']);
-  const alias = generateUniqueAlias('test', existingAliases);
-  assert.equal(alias, 'test_2');
-});
-
-GenerateUniqueAlias('handles case-insensitivity when checking for existing aliases', () => {
-  const existingAliases = new Set(['Test']);
-  const alias = generateUniqueAlias('test', existingAliases);
-  assert.equal(alias, 'test_1');
-});
-
-GenerateUniqueAlias('handles case-insensitivity for new alias generation', () => {
-  const existingAliases = new Set(['test']);
-  const alias = generateUniqueAlias('Test', existingAliases);
-  // Since input baseAlias is 'Test', it tries 'Test'. 'Test' matches 'test' case-insensitively.
-  // Next attempt 'Test_1'.
-  assert.equal(alias, 'Test_1');
-});
-
-GenerateUniqueAlias('handles mixed case existing aliases', () => {
-  const existingAliases = new Set(['TeSt', 'tEsT_1']);
-  const alias = generateUniqueAlias('test', existingAliases);
-  assert.equal(alias, 'test_2');
-});
-
-GenerateUniqueAlias.run();

package/src/new/utils/alias-generator.ts

@@ -1,18 +0,0 @@
-/**
- * Generates a unique alias by appending a counter if the base alias already exists in the set.
- * @param baseAlias The desired alias name (usually the resource name).
- * @param existingAliases A Set of currently used aliases to check against.
- * @returns A unique alias string.
- */
-export function generateUniqueAlias(baseAlias: string, existingAliases: Set<string>): string {
-  const existingAliasesLower = new Set(
-    Array.from(existingAliases).map((alias) => alias.toLowerCase()),
-  );
-  let uniqueAlias = baseAlias;
-  let counter = 1;
-  while (existingAliasesLower.has(uniqueAlias.toLowerCase())) {
-    uniqueAlias = `${baseAlias}_${counter}`;
-    counter += 1;
-  }
-  return uniqueAlias;
-}

package/src/new/utils/date-filter-params.ts

@@ -1,28 +0,0 @@
-export const getFilterParams = () => {
-  return {
-    comparator: (filterDate: Date, cellValue: number) => {
-      if (!cellValue) return -1;
-
-      const cellValueTime = new Date(cellValue).setHours(0, 0, 0, 0);
-      const filterValueTime = filterDate.getTime();
-
-      if (cellValueTime === filterValueTime) {
-        return 0;
-      }
-
-      if (cellValueTime < filterValueTime) {
-        return -1;
-      }
-
-      if (cellValueTime > filterValueTime) {
-        return 1;
-      }
-    },
-    buttons: ['reset', 'apply'],
-    closeOnApply: true,
-    closeOnClear: true,
-    suppressAndOrCondition: true,
-    browserDatePicker: true,
-    filterOptions: ['equals', 'lessThan', 'greaterThan'],
-  };
-};

package/src/new/utils/endpoint.test.ts

@@ -1,193 +0,0 @@
-import { Connect } from '@genesislcap/foundation-comms';
-import { assert, sinon, suite } from '@genesislcap/foundation-testing';
-import { getDatasourceSchema, getEndpointUrl } from './endpoint';
-
-const GetDatasourceSchema = suite('getDatasourceSchema');
-
-GetDatasourceSchema.before.each(() => {
-  sinon.restore();
-});
-
-GetDatasourceSchema('returns schema items when response is valid', async () => {
-  const mockConnect = {
-    getJSONSchema: sinon.stub(),
-  };
-
-  const mockResponse = {
-    OUTBOUND: {
-      properties: {
-        REPLY: {
-          items: {
-            type: 'object',
-            properties: {},
-          },
-        },
-      },
-    },
-  };
-
-  mockConnect.getJSONSchema.resolves(mockResponse);
-  const getSchema = getDatasourceSchema(mockConnect as unknown as Connect);
-  const result = await getSchema('TEST_RESOURCE');
-
-  assert.equal(result, mockResponse.OUTBOUND.properties.REPLY.items);
-});
-
-GetDatasourceSchema('surfaces server error response instead of a shape error', async () => {
-  const mockConnect = {
-    getJSONSchema: sinon.stub(),
-  };
-
-  const mockResponse = {
-    MESSAGE_TYPE: 'JSON_SCHEMA_NACK',
-    ERROR: [
-      {
-        '@type': 'StandardError',
-        CODE: 'FEATURE_NOT_FOUND',
-        STATUS_CODE: '404 Not Found',
-        TEXT: 'Feature not found',
-      },
-    ],
-  };
-
-  mockConnect.getJSONSchema.resolves(mockResponse);
-  const getSchema = getDatasourceSchema(mockConnect as unknown as Connect);
-
-  try {
-    await getSchema('Allocations');
-    assert.unreachable('Expected function to throw');
-  } catch (error) {
-    assert.equal(
-      error.message,
-      'Failed to fetch JSON schema for Allocations: 404 Not Found - FEATURE_NOT_FOUND - Feature not found',
-    );
-  }
-});
-
-GetDatasourceSchema('throws error when items is missing', async () => {
-  const mockConnect = {
-    getJSONSchema: sinon.stub(),
-  };
-
-  const mockResponse = {
-    OUTBOUND: {
-      properties: {
-        REPLY: {
-          type: 'object',
-        },
-      },
-    },
-  };
-
-  mockConnect.getJSONSchema.resolves(mockResponse);
-  const getSchema = getDatasourceSchema(mockConnect as unknown as Connect);
-
-  try {
-    await getSchema('TEST_RESOURCE');
-    assert.unreachable('Expected function to throw');
-  } catch (error) {
-    assert.equal(error.message, 'Invalid response shape for TEST_RESOURCE');
-  }
-});
-
-GetDatasourceSchema('throws error when REPLY is not an object', async () => {
-  const mockConnect = {
-    getJSONSchema: sinon.stub(),
-  };
-
-  const mockResponse = {
-    OUTBOUND: {
-      properties: {
-        REPLY: 'not an object',
-      },
-    },
-  };
-
-  mockConnect.getJSONSchema.resolves(mockResponse);
-  const getSchema = getDatasourceSchema(mockConnect as unknown as Connect);
-
-  try {
-    await getSchema('TEST_RESOURCE');
-    assert.unreachable('Expected function to throw');
-  } catch (error) {
-    assert.equal(error.message, 'Invalid response shape for TEST_RESOURCE');
-  }
-});
-
-GetDatasourceSchema('throws error when items is an array', async () => {
-  const mockConnect = {
-    getJSONSchema: sinon.stub(),
-  };
-
-  const mockResponse = {
-    OUTBOUND: {
-      properties: {
-        REPLY: {
-          items: [],
-        },
-      },
-    },
-  };
-
-  mockConnect.getJSONSchema.resolves(mockResponse);
-  const getSchema = getDatasourceSchema(mockConnect as unknown as Connect);
-
-  try {
-    await getSchema('TEST_RESOURCE');
-    assert.unreachable('Expected function to throw');
-  } catch (error) {
-    assert.equal(error.message, 'Items is an array');
-  }
-});
-
-GetDatasourceSchema.run();
-
-const GetEndpointUrl = suite('getEndpointUrl');
-
-GetEndpointUrl.before.each(() => {
-  sinon.restore();
-  // Clear sessionStorage before each test
-  sessionStorage.clear();
-});
-
-GetEndpointUrl('returns correct http URL for localhost', () => {
-  const endpoint = 'api/data';
-  const urlRoot = 'http://localhost:3000';
-  const result = getEndpointUrl(endpoint, urlRoot);
-  assert.equal(result, 'http://localhost:3000/api/data');
-});
-
-GetEndpointUrl('returns correct https URL for non-localhost', () => {
-  const endpoint = 'api/data';
-  const urlRoot = 'https://example.com';
-  const result = getEndpointUrl(endpoint, urlRoot);
-  assert.equal(result, 'https://example.com/api/data');
-});
-
-GetEndpointUrl('handles urlRoot with trailing slash correctly', () => {
-  const endpoint = 'api/data';
-  const urlRoot = 'https://example.com/';
-  const result = getEndpointUrl(endpoint, urlRoot);
-  assert.equal(result, 'https://example.com/api/data');
-});
-
-GetEndpointUrl('handles urlRoot with path correctly', () => {
-  const endpoint = 'api/data';
-  const urlRoot = 'https://example.com/base/path';
-  const result = getEndpointUrl(endpoint, urlRoot);
-  assert.equal(result, 'https://example.com/base/path/api/data');
-});
-
-GetEndpointUrl('uses sessionStorage hostUrl when urlRoot is not provided', () => {
-  sessionStorage.setItem('hostUrl', 'https://example.com/base');
-  const endpoint = 'api/data';
-  const result = getEndpointUrl(endpoint);
-  assert.equal(result, 'https://example.com/base/api/data');
-});
-
-GetEndpointUrl('throws error when no valid URL is provided', () => {
-  const endpoint = 'api/data';
-  assert.throws(() => getEndpointUrl(endpoint), 'Invalid URL');
-});
-
-GetEndpointUrl.run();

package/src/new/utils/endpoint.ts

@@ -1,62 +0,0 @@
-import { Connect, Message, Session } from '@genesislcap/foundation-comms';
-import { DI } from '@genesislcap/web-core';
-import { Genesis } from '../types';
-
-export const tryReadFromSession = (key: string) => {
-  const container = DI.getOrCreateDOMContainer();
-  const session = container.get(Session);
-  // session.getSessionStorageItem accounts for namespaced storage
-  return session.getSessionStorageItem(key) || sessionStorage.getItem(key) || '';
-};
-
-export const getEndpointUrl = (
-  endpoint: string,
-  urlRoot: string = tryReadFromSession('hostUrl'),
-): string => {
-  const url = new URL(urlRoot);
-  const path =
-    url.pathname && url.pathname[url.pathname.length - 1] == '/'
-      ? url.pathname
-      : `${url.pathname}/`;
-  if (urlRoot.includes('localhost')) {
-    return `http://${url.host}${path}${endpoint}`;
-  } else {
-    return `https://${url.host}${path}${endpoint}`;
-  }
-};
-
-export const getDatasourceSchema = (connect: Connect) => async (resourceName: string) => {
-  const result = await connect.getJSONSchema(resourceName);
-  // A server-side failure (e.g. JSON_SCHEMA_NACK) comes back as an error message rather
-  // than a schema. Surface that error directly instead of masking it as a shape problem.
-  const errors = (result as unknown as Message)?.ERROR;
-  if (Array.isArray(errors) && errors.length) {
-    throw new Error(
-      `Failed to fetch JSON schema for ${resourceName}: ${errors
-        .map((error) => [error?.STATUS_CODE, error?.CODE, error?.TEXT].filter(Boolean).join(' - '))
-        .join('; ')}`,
-    );
-  }
-  if (
-    typeof result.OUTBOUND?.properties?.['REPLY'] !== 'object' ||
-    !result.OUTBOUND?.properties?.['REPLY'].items ||
-    typeof result.OUTBOUND?.properties?.['REPLY'].items === 'boolean'
-  )
-    throw new Error(`Invalid response shape for ${resourceName}`);
-  // TODO: Karim checking this
-  if (Array.isArray(result.OUTBOUND?.properties?.['REPLY']?.items))
-    throw new Error(`Items is an array`);
-  if (
-    Object.values(result.OUTBOUND?.properties?.['REPLY']?.items?.properties ?? {}).some(
-      (p) => typeof p === 'boolean',
-    )
-  )
-    throw new Error(`Properties contain invalid values`);
-  if (
-    Object.values(
-      (<Genesis.JSONSchema7>result.OUTBOUND?.properties?.['REPLY']?.items)?.properties ?? {},
-    ).some((p) => !p.genesisType)
-  )
-    throw new Error(`Schema properties don't contain 'genesisType' field`);
-  return result.OUTBOUND?.properties?.['REPLY']?.items as Genesis.JSONSchema7;
-};

package/src/new/utils/event-map.ts

@@ -1,11 +0,0 @@
-export enum ReportingEvents {
-  highlightGridRow = 'highlight-grid-row',
-  setReportConfigDisplayMode = 'set-report-config-disp-mode',
-  refreshColumnFormatGrid = 'refresh-column-format-grid',
-}
-
-export type ReportingEventDetailMap = {
-  [ReportingEvents.highlightGridRow]: string;
-  [ReportingEvents.setReportConfigDisplayMode]: 'list' | 'edit';
-  [ReportingEvents.refreshColumnFormatGrid]: void;
-};

package/src/new/utils/format-utils.ts

@@ -1,22 +0,0 @@
-import type { Genesis } from '../types';
-
-export const getDefaultFormat = (type: Genesis.GenesisFieldTypes) => {
-  if (isNumericFieldType(type)) {
-    if (type === 'BIGDECIMAL' || type === 'DOUBLE') {
-      return '#.##';
-    }
-    return '#';
-  } else if (type === 'DATE') {
-    return 'dd/MM/yyyy';
-  } else if (type === 'DATETIME') {
-    return 'dd/MM/yyyy HH:mm:ss';
-  }
-  return '';
-};
-
-// Helper function to check if a field type is numeric
-const isNumericFieldType = (
-  fieldType: string,
-): fieldType is 'DOUBLE' | 'BIGDECIMAL' | 'INT' | 'SHORT' | 'LONG' => {
-  return ['DOUBLE', 'BIGDECIMAL', 'INT', 'SHORT', 'LONG'].includes(fieldType);
-};

package/src/new/utils/formatters.ts

@@ -1,36 +0,0 @@
-import {
-  DateStandardFormats,
-  DateTimeFormats,
-  DateYearFormats,
-} from '../main/edit-config/data-transforms-derived-fields/data-transforms.types';
-
-export const formatDate = (timestamp) => {
-  if (!timestamp) {
-    return ''; // to show blank cell in case date is not provided, otherwise defaults to timestamp
-  }
-  const date = new Date(timestamp);
-  return new Intl.DateTimeFormat('en-GB', {
-    day: '2-digit',
-    month: 'short',
-    year: 'numeric',
-  }).format(date);
-};
-
-export const getFormattedDateTime = (timestamp) => {
-  const dateTime = new Date(timestamp);
-  return `${formatDate(timestamp)} ${dateTime.toLocaleTimeString()}`;
-};
-
-export const getDateFormatOptions = (gridFormat): Intl.DateTimeFormatOptions => ({
-  year: gridFormat.year === DateYearFormats.Full ? DateStandardFormats.Numeric : gridFormat.year,
-  month: gridFormat.month,
-  day: gridFormat.day,
-  timeZone: 'UTC',
-  ...(gridFormat.hour && gridFormat.hour !== DateTimeFormats.Hide ? { hour: gridFormat.hour } : {}),
-  ...(gridFormat.minute && gridFormat.minute !== DateTimeFormats.Hide
-    ? { minute: gridFormat.minute }
-    : {}),
-  ...(gridFormat.second && gridFormat.second !== DateTimeFormats.Hide
-    ? { second: gridFormat.second }
-    : {}),
-});

package/src/new/utils/index.ts

@@ -1,10 +0,0 @@
-export * from './alias-generator';
-export * from './endpoint';
-export * from './formatters';
-export * from './notifications';
-export * from './renderer';
-export * from './rights';
-export * from './sorter';
-export * from './tooltip';
-export * from './transformers';
-export * from './validators';

package/src/new/utils/notifications.ts

@@ -1,9 +0,0 @@
-import {
-  getNotificationContainer,
-  ToastStructure,
-  showNotificationToast as toast,
-} from '@genesislcap/foundation-notifications';
-
-const container = getNotificationContainer('notify-container', 'rapid');
-
-export const showNotificationToast = (config: ToastStructure) => toast(config, 'rapid', container);