@qrvey/utils 1.2.10-9 → 1.3.0-10

package/scripts/clean-build/index.js

@@ -0,0 +1,62 @@
+/**
+ * Script for cleaning the project from temporary files and building a new bundle
+ * 1- Deleting some directories and files
+ * 2- Installing dependencies
+ * 3- Build a new bundle
+ */
+
+const util = require('util');
+const childProcess = require('child_process');
+const exec = util.promisify(childProcess.exec);
+const { exit } = require('process');
+ 
+async function execute(command) {
+    console.log(command);
+    const response = await exec(command);
+    if (response.error != null) {
+        throw new Error(response.error);
+    }
+    if (response.stderr != null && response.stderr !== '') {
+        console.error(response.stderr);
+    }
+    if (response.stdout != null && response.stdout !== '') {
+        console.log(response.stdout);
+    }
+    return response;
+}
+
+async function cleaningProject(settings) {
+    console.log('==>>> Cleaning project...');
+    await execute(`rm -f ${settings.packageLockPath}`);
+    await execute(`rm -f -R ${settings.nodeModulesPath}`);
+    await execute(`rm -f -R ${settings.distPath}`);
+}
+
+async function buildingBundle(_settings) {
+    console.log('==>>> Installing Dependencies...');
+    await execute('npm install');
+
+    await execute('npm run build');
+}
+
+async function init() {
+    console.log('Welcome.');
+    let settings = {
+        distPath: './dist',
+        nodeModulesPath: './node_modules',
+        packageLockPath: './package-lock.json',
+    };
+
+    try {
+        await cleaningProject(settings);
+        await buildingBundle(settings);
+        console.info('Finished cleaning and installed dependencies');
+    } catch (err) {
+        console.error('Error: ', err);
+    } finally {
+        console.log('Execution finished');
+        exit();
+    }
+}
+ 
+init();

package/scripts/generating-docs/index.js

@@ -0,0 +1,133 @@
+/**
+ * Script for cleaning the project from temporary files and building a new bundle
+ * 1- Deleting some directories and files
+ * 2- Installing dependencies
+ * 3- Build a new bundle
+ */
+
+const fs = require('fs');
+const util = require('util');
+const childProcess = require('child_process');
+const exec = util.promisify(childProcess.exec);
+const proc = require('process');
+const readline = require("readline");
+const rl = readline.createInterface({
+    input: proc.stdin,
+    output: proc.stdout
+});
+const question = util.promisify(rl.question).bind(rl);
+const { exit } = require('process');
+  
+async function execute(command) {
+    console.log(command);
+    const response = await exec(command);
+    if (response.error != null) {
+        throw new Error(response.error);
+    }
+    if (response.stderr != null && response.stderr !== '') {
+        console.error(response.stderr);
+    }
+    if (response.stdout != null && response.stdout !== '') {
+        console.log(response.stdout);
+    }
+    return response;
+}
+
+async function getPackageJson(settings) {
+    console.log('==>>> Opening package.json file...');
+    const packageJson = await fs.readFileSync(settings.packagePath, 'utf8');
+    const packageObject = JSON.parse(packageJson);
+    if (packageObject != null) {
+        console.log(`**** The current version is ${packageObject.version}`);
+        return packageObject.version;
+    }
+    return '';
+}
+
+async function getNewVersion() {
+    console.log('==>>> Checking the new version provided...');
+    let newVersion;
+    const versionIndex = proc.argv.findIndex(function (argv) { return argv.includes('--np-new-version='); });
+    if (versionIndex > -1) {
+        const versionArg = proc.argv[versionIndex].split('--np-new-version=');
+        newVersion = versionArg[1] == null || versionArg[1] === '' ? undefined : versionArg[1];
+    }
+    if (newVersion == null) {
+        newVersion = await question('No version provided. Type the new version: ');
+    }
+    console.log('**** Version to publish: ' + newVersion);
+    return newVersion;
+}
+
+async function startGeneratingDocs(settings) {
+    console.log('==>>> Starting the Docs generation');
+
+    await generatingDocument(settings);
+    await changingVersion(settings);
+    await pushingChanges(settings);
+}
+
+async function generatingDocument(_settings) {
+    console.log('==>>> Generating Document...');
+    await execute('npm run compodoc');
+}
+
+async function changingVersion(settings) {
+    console.log('==>>> Replacing the old version in the document');
+    const doc = await fs.readFileSync(settings.docsPath, 'utf8');
+    const replacedDoc = doc.replace(settings.currentVersion, settings.newVersion);
+    await fs.writeFileSync(settings.docsPath, replacedDoc, 'utf8');
+}
+
+async function pushingChanges(settings) {
+    console.log('==>>> Commiting and Pushing Docs changes...');
+
+    const gitStatus = await execute('git status -s');
+    console.log('gitStatus', gitStatus);
+    if (gitStatus.stdout !== '') {
+        const gitStdout = await execute('git rev-parse --abbrev-ref HEAD');
+        console.log('gitStdout', gitStdout);
+        await execute(`git add ${settings.docsPath}`);
+        await execute(`git commit -m "📝 docs: Updated docs${settings.newVersion != null || settings.newVersion !== '' ? ' for ' + settings.newVersion : ''}"`);
+        await execute(`git push -u origin ${gitStdout.stdout}`);
+    } else {
+        console.log('Nothing to Push');
+    }
+}
+ 
+ async function revertChanges(settings) {
+    console.log('>>> Checking for modifications...');
+    console.warn(`>>> Unstaging posible changes from ${settings.docsFileName} and ${settings.packageFileName} file`);
+    await execute(`git restore --staged ${settings.docsPath} ${settings.packagePath}`);
+    console.warn(`>>> Discarting posible changes of ${settings.docsFileName} and ${settings.packageFileName} file`);
+    await execute(`git checkout -- ${settings.docsPath} ${settings.packagePath}`);
+}
+
+ async function init() {
+    console.log('Generating Docs execution.');
+    let settings = {
+        currentVersion: '',
+        docsPath: './README.md',
+        docsFileName: 'README.md',
+        newVersion: undefined,
+        packageFileName: 'package.json',
+        packagePath: './package.json',
+     };
+ 
+    try {
+        settings["currentVersion"] = await getPackageJson(settings);
+        settings["newVersion"] = await getNewVersion();
+
+        await startGeneratingDocs(settings);
+        console.info('Docs were generated.');
+    } catch (err) {
+        console.error('Error: ', err);
+        await revertChanges(settings);
+    } finally {
+        console.log('Execution finished');
+        exit();
+    }
+ }
+  
+ init();
+ 

package/{publishing.js → scripts/publishing/index.js}

@@ -153,11 +153,17 @@ async function changingVersion(settings) {
 async function pushingChanges(settings) {
     console.log('==>>> Commiting and Pushing Docs changes...');
 
-    const gitStdout = await execute('git rev-parse --abbrev-ref HEAD');
-    console.log('gitStdout', gitStdout);
-    await execute(`git add ${settings.docsPath}`);
-    await execute(`git commit -m "📝 docs: Updated docs${settings.newVersion != null || settings.newVersion !== '' ? ' for ' + settings.newVersion : ''}"`);
-    await execute(`git push -u origin ${gitStdout.stdout}`);
+    const gitStatus = await execute('git status -s');
+    console.log('gitStatus', gitStatus);
+    if (gitStatus.stdout !== '') {
+        const gitStdout = await execute('git rev-parse --abbrev-ref HEAD');
+        console.log('gitStdout', gitStdout);
+        await execute(`git add ${settings.docsPath}`);
+        await execute(`git commit -m "📝 docs: Updated docs${settings.newVersion != null || settings.newVersion !== '' ? ' for ' + settings.newVersion : ''}"`);
+        await execute(`git push -u origin ${gitStdout.stdout}`);
+    } else {
+        console.log('Nothing to Push');
+    }
 }
 
 async function revertChanges(settings) {
@@ -179,7 +185,6 @@ async function init() {
         packageFileName: 'package.json',
         packageLockPath: './package-lock.json',
         packagePath: './package.json',
-        
     };
 
     console.log('Welcome. The publishing operationg will begin.');

package/src/charts/constants/index.ts

@@ -1,5 +1,4 @@
 export * from './AGGREGATE_ABBREVIATION';
-export * from './AGGREGATE_GENERAL';
 export * from './AGGREGATE_INFO_LIST';
 export * from './AGGREGATE_INFO';
 export * from './AGGREGATE_LABEL';

package/src/column_format/constants/CHART_GROUP.ts

@@ -0,0 +1,4 @@
+export enum CHART_GROUPS {
+    TABLES = 'tables',
+    XY = 'xy'
+}

package/src/column_format/constants/DATEGROUP_UNSUPPORT_FORMAT.ts

@@ -0,0 +1,14 @@
+import { DATEGROUP_WITHOUT_FORMAT } from "./DATEGROUP_WITHOUT_FORMAT";
+
+export const DATEGROUP_UNSUPPORT_FORMAT = [
+    DATEGROUP_WITHOUT_FORMAT.YEAR,
+    DATEGROUP_WITHOUT_FORMAT.QUARTER,
+    DATEGROUP_WITHOUT_FORMAT.MONTH,
+    DATEGROUP_WITHOUT_FORMAT.WEEK,
+    DATEGROUP_WITHOUT_FORMAT.QUARTER_ONLY,
+    DATEGROUP_WITHOUT_FORMAT.MONTH_ONLY,
+    DATEGROUP_WITHOUT_FORMAT.DAY_ONLY,
+    DATEGROUP_WITHOUT_FORMAT.HOUR_ONLY,
+    DATEGROUP_WITHOUT_FORMAT.MINUTE_ONLY,
+    DATEGROUP_WITHOUT_FORMAT.SECOND_ONLY
+];

package/src/column_format/constants/DATEGROUP_WITHOUT_FORMAT.ts

@@ -0,0 +1,12 @@
+export enum DATEGROUP_WITHOUT_FORMAT  {
+    YEAR = 'YEAR',
+    QUARTER = 'QUARTER',
+    MONTH = 'MONTH',
+    WEEK = 'WEEK',
+    QUARTER_ONLY = 'QUARTER_ONLY',
+    MONTH_ONLY = 'MONTH_ONLY',
+    DAY_ONLY = 'DAY_ONLY',
+    HOUR_ONLY = 'HOUR_ONLY',
+    MINUTE_ONLY = 'MINUTE_ONLY',
+    SECOND_ONLY = 'SECOND_ONLY'
+}

package/src/column_format/constants/SHELF_TYPE.ts

@@ -0,0 +1,7 @@
+export enum SHELF_TYPE {
+    CATEGORY = 'category',
+    VALUE = 'value',
+    GROUPS = 'groups',
+    COLUMNS = 'columns',
+    SERIES = 'series'
+}

package/src/column_format/constants/STRING_FORMAT.ts

@@ -0,0 +1,3 @@
+export enum STRING_FORMAT {
+    NONE = 'none'
+}

package/src/column_format/constants/TABLE_TYPE.ts

@@ -0,0 +1,5 @@
+export enum TABLE_TYPE {
+    SIMPLE = 'simple',
+    GROUPED = 'grouped',
+    EXPANDABLE = 'expandable'
+}

package/src/column_format/constants/index.ts

@@ -0,0 +1,6 @@
+export * from './CHART_GROUP';
+export * from './DATEGROUP_UNSUPPORT_FORMAT';
+export * from './DATEGROUP_WITHOUT_FORMAT';
+export * from './SHELF_TYPE';
+export * from './STRING_FORMAT';
+export * from './TABLE_TYPE';

package/src/column_format/helpers/columnTypeByChart.ts

@@ -0,0 +1,27 @@
+import { NUMERICAL_COLUMN, NUMERICAL_COLUMNS } from "../..";
+import { COLUMN } from "../../columns";
+import { CHART_GROUPS } from "../constants/CHART_GROUP";
+import { SHELF_TYPE } from "../constants/SHELF_TYPE";
+import { IChartColumn } from "../interfaces/IChartColumn";
+import { IChartGroupType } from "../interfaces/IChartGroupType";
+import { IChartShelfType } from "../interfaces/IChartShelfType";
+import { parseFormulaTypeByCharts } from "./parseFormulaTypeByCharts";
+
+/**
+ * It returns the column type for a given column, shelf type, chart group, and whether the table is
+ * grouped or not
+ * @param {IChartColumn} column - IChartColumn
+ * @param {IChartShelfType} shelfType - IChartShelfType
+ * @param {IChartGroupType} chartGroup - IChartGroupType
+ * @param {boolean} [isGroupedTable] - boolean - this is a boolean that is true if the table is
+ * grouped.
+ * @returns The column type of the column.
+ */
+export const columnTypeByChart = (column: IChartColumn, shelfType: IChartShelfType, chartGroup: IChartGroupType, isGroupedTable?: boolean) => {
+    if (!column) return;
+    const currentType = column.type === COLUMN.FORMULA ? parseFormulaTypeByCharts(column.formulaType) : column.type;
+    const isNumericalColumn = NUMERICAL_COLUMNS.some(colType => colType === currentType)
+     || ((chartGroup === CHART_GROUPS.TABLES) && (isGroupedTable === true) && (shelfType === SHELF_TYPE.COLUMNS))
+      || ((chartGroup === CHART_GROUPS.XY) && (shelfType === SHELF_TYPE.VALUE || shelfType === SHELF_TYPE.SERIES));
+    return isNumericalColumn === true ? NUMERICAL_COLUMN.NUMERIC : currentType;
+};

package/src/column_format/helpers/defineFormatV2.ts

@@ -0,0 +1,17 @@
+import { IChartColumn } from "../interfaces/IChartColumn";
+import { IColumnFormatReturnType } from "../interfaces/IColumnFormatReturnType";
+import { IColumnFormatSettings } from "../interfaces/IColumnFormatSettings";
+import { defineTableChartFormat } from "./defineTableChartFormat";
+import { defineXYChartFormat } from "./defineXYChartFormat";
+
+/**
+ * > If the chart is a table chart, then define the format for a table chart, otherwise define the
+ * format for an XY chart
+ * @param {IChartColumn} column - IChartColumn - this is the column object that is passed to the chart.
+ * @param {IColumnFormatSettings} settings - IColumnFormatSettings
+ * @returns IColumnFormatReturnType
+ */
+export const defineFormatV2 = (column: IChartColumn, settings: IColumnFormatSettings) : IColumnFormatReturnType => {
+    const { isTableChart, isXYChart } = settings;
+    return isTableChart && !isXYChart ? defineTableChartFormat(column, settings) : defineXYChartFormat(column, settings);
+};

package/src/column_format/helpers/defineTableChartFormat.ts

@@ -0,0 +1,70 @@
+import { AGGREGATE, COLUMN, isEmpty } from "../..";
+import { CHART_GROUPS } from "../constants/CHART_GROUP";
+import { DATEGROUP_UNSUPPORT_FORMAT } from "../constants/DATEGROUP_UNSUPPORT_FORMAT";
+import { STRING_FORMAT } from "../constants/STRING_FORMAT";
+import { TABLE_TYPE } from "../constants/TABLE_TYPE";
+import { IChartColumn } from "../interfaces/IChartColumn";
+import { IColumnFormatReturnType } from "../interfaces/IColumnFormatReturnType";
+import { IColumnFormatSettings } from "../interfaces/IColumnFormatSettings";
+import { columnTypeByChart } from "./columnTypeByChart";
+
+/**
+ * It returns the format of a column based on the column type, the chart type, and the chart settings
+ * @param {IChartColumn} column - IChartColumn
+ * @param {IColumnFormatSettings} settings - IColumnFormatSettings
+ */
+export const defineTableChartFormat = (column: IChartColumn, settings: IColumnFormatSettings) : IColumnFormatReturnType => {
+    const { aggregate, type, defaultFormat, outputFormat, selectedFormat, dateGroup } = column;
+    const { tableType, shelfType } = settings;
+    //Defaults
+    const defaultText = 'Default';
+    const defaultNumeric = { type: 'NUMERIC', format: 'Numeric' };
+    const defaultAbb = { type: 'NUMERIC', format: 'Abbreviated' };
+
+    const isGroupedTable = tableType === TABLE_TYPE.GROUPED;
+    const columnType = columnTypeByChart(column, shelfType, CHART_GROUPS.TABLES, isGroupedTable);
+
+    const noFormatSupported = DATEGROUP_UNSUPPORT_FORMAT.some(gp => gp === dateGroup?.label);
+    const hasDefaultFormat = isEmpty(selectedFormat) && outputFormat?.format === defaultText;
+    const isUsedAsNumericColumn = type !== columnType;
+
+
+    switch(columnType) {
+        case COLUMN.YES_NO:
+        case COLUMN.PHONE:
+        case COLUMN.SINGLE_CHOICE:
+        case COLUMN.LONGTEXT:
+        case COLUMN.DROPDOWN:
+        case COLUMN.EXPRESSION:
+        case COLUMN.NAME:
+        case COLUMN.EMAIL_FORM:
+        case COLUMN.IMAGE:
+        case COLUMN.TEXT_LABEL:
+            return STRING_FORMAT.NONE;
+        case COLUMN.DATE: {
+            if(noFormatSupported) {
+                return STRING_FORMAT.NONE;
+            }
+            else if(hasDefaultFormat) {
+                return { ...defaultFormat, format: defaultText, originalFormat: { ...column.outputFormat } };
+            }
+            else {
+                return selectedFormat;
+            }
+        }
+        case COLUMN.NUMERIC:
+        case COLUMN.RATING:
+        case COLUMN.SLIDEBAR: {
+            if(isUsedAsNumericColumn) {
+                if(aggregate?.label === AGGREGATE.COUNT && hasDefaultFormat) return defaultNumeric;
+                else if(hasDefaultFormat) return defaultAbb;
+                else return outputFormat;
+            } else {
+                if(hasDefaultFormat) {
+                    return { ...defaultFormat, format: defaultText, originalFormat: { ...column.outputFormat } };
+                }
+                else return selectedFormat;
+            }
+        }
+    }
+};

package/src/column_format/helpers/defineXYChartFormat.ts

@@ -0,0 +1,79 @@
+import { AGGREGATE, COLUMN, isEmpty } from "../..";
+import { CHART_GROUPS } from "../constants/CHART_GROUP";
+import { DATEGROUP_UNSUPPORT_FORMAT } from "../constants/DATEGROUP_UNSUPPORT_FORMAT";
+import { STRING_FORMAT } from "../constants/STRING_FORMAT";
+import { IChartColumn } from "../interfaces/IChartColumn";
+import { IColumnFormatReturnType } from "../interfaces/IColumnFormatReturnType";
+import { IColumnFormatSettings } from "../interfaces/IColumnFormatSettings";
+import { columnTypeByChart } from "./columnTypeByChart";
+
+/**
+ * > It returns the format of a column based on the column's type, the chart's type, and the column's
+ * aggregate
+ * > Also, if the settings contains the prop withoutFormat as true, returns the default format
+ * @param {IChartColumn} column - IChartColumn
+ * @param {IColumnFormatSettings} settings - IColumnFormatSettings
+ */
+export const defineXYChartFormat = (column: IChartColumn, settings: IColumnFormatSettings) : IColumnFormatReturnType => {
+    const { aggregate, type, defaultFormat, outputFormat, selectedFormat, dateGroup } = column;
+    const { shelfType, withoutFormat } = settings;
+
+    //Defaults
+    const defaultText = 'Default';
+    //const defaultNumeric = { type: 'NUMERIC', format: 'Numeric' };
+    const defaultAbb = { type: 'NUMERIC', format: 'Abbreviated' };
+
+    const columnType = columnTypeByChart(column, shelfType, CHART_GROUPS.XY);
+
+    const noFormatSupported = DATEGROUP_UNSUPPORT_FORMAT.some(gp => gp === dateGroup?.label);
+    const isUsedAsNumericColumn = type !== columnType;
+    const hasDefaultFormat = isEmpty(selectedFormat) || (outputFormat?.format === defaultText) || (selectedFormat?.format === defaultText);
+
+
+    switch(columnType) {
+        case COLUMN.YES_NO:
+        case COLUMN.PHONE:
+        case COLUMN.SINGLE_CHOICE:
+        case COLUMN.LONGTEXT:
+        case COLUMN.DROPDOWN:
+        case COLUMN.EXPRESSION:
+        case COLUMN.NAME:
+        case COLUMN.EMAIL_FORM:
+        case COLUMN.IMAGE:
+        case COLUMN.TEXT_LABEL:
+            return STRING_FORMAT.NONE;
+        case COLUMN.DATE: {
+            if(noFormatSupported) {
+                return STRING_FORMAT.NONE;
+            }
+            else if(hasDefaultFormat) {
+                return { ...defaultFormat, format: defaultText, originalFormat: { ...outputFormat } };
+            }
+            else {
+                return selectedFormat;
+            }
+        }
+        case COLUMN.NUMERIC:
+        case COLUMN.RATING:
+        case COLUMN.SLIDEBAR: {
+            if(isUsedAsNumericColumn) {
+                if(
+                    (aggregate?.label === AGGREGATE.COUNT && hasDefaultFormat)
+                     || 
+                    (isUsedAsNumericColumn && outputFormat?.type !== COLUMN.NUMERIC)
+                     ||
+                    withoutFormat
+                    ) return defaultAbb;
+                else return outputFormat;
+            } else {
+                if(withoutFormat === true) {
+                    return defaultFormat;
+                }
+                else if(hasDefaultFormat) {
+                    return { ...outputFormat };
+                }
+                else return selectedFormat;
+            }
+        }
+    }
+};

package/src/column_format/helpers/index.ts

@@ -0,0 +1,5 @@
+export * from './columnTypeByChart';
+export * from './defineFormatV2';
+export * from './defineTableChartFormat';
+export * from './defineXYChartFormat';
+export * from './parseFormulaTypeByCharts';

package/src/column_format/helpers/parseFormulaTypeByCharts.ts

@@ -0,0 +1,17 @@
+import { FORMULA, IFormulaType } from "../..";
+
+/**
+ * It takes a string and returns a string
+ * @param {IFormulaType} type - IFormulaType - this is the type of the formula.
+ * @returns The type of the formula.
+ */
+export const parseFormulaTypeByCharts = (type: IFormulaType) => {
+    switch (type) {
+        case FORMULA.NUMBER:
+            return 'NUMERIC';
+        case FORMULA.DATE:
+            return 'DATE';
+        default:
+            return 'TEXT_LABEL';
+    }
+};

package/src/column_format/index.ts

@@ -0,0 +1,3 @@
+export * from './constants/index';
+export * from './helpers/index';
+export * from './interfaces/index';

package/src/column_format/interfaces/IChartColumn.ts

@@ -0,0 +1,24 @@
+import { IColumnSortingSettings, IColumnType, IFormatOutputFormat, IFormulaType } from "../..";
+import { IColumnAggregate } from "../../columns/interfaces/IColumnAggregate";
+import { IColumnDateGroupSettings } from "../../columns/interfaces/IColumnDateGroupSettings";
+import { IColumnScale } from "../../columns/interfaces/IColumnScale";
+import { IFormatDefaultFormat } from "../../interfaces/format/IFormatDefaultFormat";
+
+export interface IChartColumn {
+    aggregate: IColumnAggregate;
+    colIndex: number;
+    dateGroup?: IColumnDateGroupSettings;
+    defaultFormat: IFormatDefaultFormat;
+    format?: string;
+    formulaType?: IFormulaType;
+    groupAgg: string;
+    id: string;
+    isGroup: string;
+    outputFormat: IFormatOutputFormat;
+    property: string;
+    scaleType?: IColumnScale;
+    selectedFormat?: IFormatDefaultFormat;
+    sorting?: IColumnSortingSettings;
+    text: string;
+    type: IColumnType;
+}

package/src/column_format/interfaces/IChartGroupType.ts

@@ -0,0 +1,3 @@
+import { CHART_GROUPS } from "../constants/CHART_GROUP";
+
+export type IChartGroupType = CHART_GROUPS;

package/src/column_format/interfaces/IChartShelfType.ts

@@ -0,0 +1,3 @@
+import { SHELF_TYPE } from "../constants/SHELF_TYPE";
+
+export type IChartShelfType = SHELF_TYPE;

package/src/column_format/interfaces/IChartTableType.ts

@@ -0,0 +1,3 @@
+import { TABLE_TYPE } from "../constants/TABLE_TYPE";
+
+export type IChartTableType = TABLE_TYPE;

package/src/column_format/interfaces/IColumnFormatReturnType.ts

@@ -0,0 +1,4 @@
+import { IFormatOutputFormat } from "../..";
+import { IFormatStringType } from "./IFormatStringType";
+
+export type  IColumnFormatReturnType = IFormatStringType | IFormatOutputFormat;

package/src/column_format/interfaces/IColumnFormatSettings.ts

@@ -0,0 +1,11 @@
+import { IChartShelfType } from "./IChartShelfType";
+import { IChartTableType } from "./IChartTableType";
+
+/* Defining an interface for the column format settings. */
+export interface IColumnFormatSettings {
+    tableType?: IChartTableType;
+    isTableChart?: boolean;
+    isXYChart?: boolean;
+    shelfType: IChartShelfType;
+    withoutFormat: boolean;
+}

package/src/column_format/interfaces/IFormatStringType.ts

@@ -0,0 +1,3 @@
+import { STRING_FORMAT } from "../constants/STRING_FORMAT";
+
+export type IFormatStringType = STRING_FORMAT;

package/src/column_format/interfaces/index.ts

@@ -0,0 +1,7 @@
+export * from './IChartColumn';
+export * from './IChartGroupType';
+export * from './IChartShelfType';
+export * from './IChartTableType';
+export * from './IColumnFormatReturnType';
+export * from './IColumnFormatSettings';
+export * from './IFormatStringType';

package/src/columns/constants/COLUMN_LABEL.ts

@@ -17,6 +17,7 @@ export const COLUMN_LABEL = {
 	CHECKLIST: 'Check List',
 	NPS_SCORE: 'NPS Score',
 	NPS_FEEDBACK: 'NPS Feedback',
+	TEXT: 'Text',
 	TEXT_LABEL: 'Text Label',
 	TEXT_CATEGORY: 'Text Category',
 	LOOKUP: 'Lookup',

package/src/columns/constants/COLUMN_PROPERTY_INFO.ts

@@ -12,7 +12,7 @@ import { DATE_DISTINCT_TIME_PROPERTY_INFO_LIST } from "../../dates/constants/DAT
 export const COLUMN_PROPERTY_INFO: { [key in IColumnType]?: IColumnPropertyInfo[] } = {
   [COLUMN.LOOKUP]: [
     { value: COLUMN_PROPERTY.LOOKUP_DISPLAY, label: 'Display', shortLabel: 'Display', abbrLabel: 'DSY', displayed: true, i18nLabelPath: 'common.properties.lookup_display_label' },
-    { value: COLUMN_PROPERTY.LOOKUP_VALUE, label: 'Value', shortLabel: 'Value', abbrLabel: 'Val', displayed: true, i18nLabelPath: 'common.properties.lookup_display_value' }
+    { value: COLUMN_PROPERTY.LOOKUP_VALUE, label: 'Value', shortLabel: 'Value', abbrLabel: 'Val', displayed: true, i18nLabelPath: 'common.properties.lookup_value_label' }
   ],
   [COLUMN.DATE]: [
     ...DATE_GROUPING_PROPERTY_INFO_LIST,

package/src/columns/constants/index.ts

@@ -1,12 +1,7 @@
-export * from './COLUMN_IMAGE_UPLOAD_OPTION_LIST';
-export * from './COLUMN_IMAGE_UPLOAD_OPTION';
-
 export * from './COLUMN_INFO_LIST';
 export * from './COLUMN_INFO';
-export * from './COLUMN_LABEL';
 export * from './COLUMN_PROPERTIES';
 export * from './COLUMN_PROPERTY_INFO';
-export * from './COLUMN_PROPERTY_LABEL';
 export * from './COLUMN_PROPERTY';
 export * from './COLUMN';
 export * from './COLUMNS';

package/src/columns/helpers/index.ts

@@ -1,8 +1,3 @@
-export * from './getColumnsLabel';
-export * from './getDatasetByColumn';
-export * from './getDatasetColumn';
-export * from './getDatasetColumnyDatasets';
-export * from './getModelColumn';
 export * from './isComplexColumn';
 export * from './isDateColumn';
 export * from './isNumericalColumn';