@qrvey/utils 1.3.3 → 1.4.0-2

package/src/format/definition.ts

@@ -1,126 +0,0 @@
-
-import { COLUMN } from '../columns/constants/COLUMN';
-import { CHART_TYPE } from '../constants/Charts.Const';
-import { ChartType } from '../interfaces/Chart.Interface';
-
-export const textFields: string[] = [COLUMN.TEXTFIELD, COLUMN.TEXT_CATEGORY, COLUMN.TEXT_LABEL, COLUMN.TEXT_CATEGORY];
-
-export const complexFields: string[] = [COLUMN.USADDRESS, COLUMN.ADDRESS, COLUMN.NAME, COLUMN.TEXTFIELD, COLUMN.LONGTEXT, COLUMN.FILEUPLOAD, COLUMN.IMAGEUPLOAD];
-
-export const numericalFields: string[] = [COLUMN.SLIDEBAR, COLUMN.NUMERIC, COLUMN.RATING];
-
-export const QUESTION_FORMAT_SUPPORT = [
-    COLUMN.DATE,
-    COLUMN.NUMERIC,
-    COLUMN.FILEUPLOAD,
-    COLUMN.IMAGEUPLOAD,
-    // COLUMN.RANKING,
-    COLUMN.RATING,
-    COLUMN.SLIDEBAR,
-    COLUMN.YES_NO,
-    COLUMN.PHONE,
-    COLUMN.SINGLE_CHOICE,
-    COLUMN.LONGTEXT,
-    COLUMN.DROPDOWN,
-    COLUMN.EXPRESSION,
-    COLUMN.NAME,
-    COLUMN.EMAIL_FORM,
-    COLUMN.IMAGE,
-    COLUMN.TEXT_LABEL
-  ];
-export const DATEGROUP_FORMATTING_UNSUPPORT = ['YEAR', 'QUARTER', 'MONTH', 'WEEK'];
-
-export const appliesFormatting = (columnType): boolean => QUESTION_FORMAT_SUPPORT.includes(columnType);
-
-export const hasfileSizeProperty = (column: any = {}): boolean => isComplexColumn(column) && column.property && (column.property.value || column.property).includes('fileSize');
-
-export const isComplexColumn = (column: any = {}): boolean => complexFields.includes(column.type);
-
-export const isNumericalColumn = (column: any = {}): boolean => numericalFields.includes(column.type) || column.formulaType === 'number';
-
-export function supportNumericFormatting(chartType: ChartType): boolean {
-    const supportedCharts = [
-      CHART_TYPE.TABLE_CHART,
-      CHART_TYPE.CROSSTAB_CHART,
-      CHART_TYPE.BAR_CHART,
-      CHART_TYPE.LINE_CHART,
-      CHART_TYPE.SYMBOL_CHART,
-      CHART_TYPE.MINMAX_CHART,
-      CHART_TYPE.BAR_CHART_MS,
-      CHART_TYPE.LINE_CHART_MS,
-      CHART_TYPE.SYMBOL_CHART_MS,
-      CHART_TYPE.COMBO_CHART
-    ];
-    return supportedCharts.includes(chartType);
-  }
-
-export const isTextColumn = (column: any): boolean => textFields.includes(column.type) || column.formulaType === 'string' || column.formulaType === 'boolean';
-
-export const currencyISO = [
-  { text: 'Default', label: 'USD' },
-  { text: '$ (USD)', label: 'USD' },
-  { text: '€ (EUR)', label: 'EUR' },
-  { text: '¥ (JPY)', label: 'JPY' },
-  { text: '£ (GBP)', label: 'GBP' },
-  { text: '₩ (WON)', label: 'WON' },
-  { text: '$ (AUD)', label: 'AUD' },
-  { text: '$ (CAD)', label: 'CAD' },
-  { text: 'CHF (CHF)', label: 'CHF' },
-  { text: '¥ (CNY)', label: 'CNY' },
-  { text: 'kr (SEK)', label: 'SEK' },
-  { text: '$ (MXN)', label: 'MXN' },
-  { text: '$ (NZD)', label: 'NZD' },
-  { text: '$ (SGD)', label: 'SGD' },
-  { text: '$ (HKD)', label: 'HKD' },
-  { text: 'kr (NOK)', label: 'NOK' },
-  { text: '₩ (KRW)', label: 'KRW' },
-  { text: '₺ (TRY)', label: 'TRY' },
-  { text: '₹ (INR)', label: 'INR' },
-  { text: '₽ (RUB)', label: 'RUB' },
-  { text: 'R$ (BRL)', label: 'BRL' },
-  { text: 'R (ZAR)', label: 'ZAR' },
-  { text: 'kr (DKK)', label: 'DKK' },
-  { text: 'zł (PLN)', label: 'PLN' },
-  { text: 'NT$ (TWD)', label: 'TWD' },
-  { text: '฿ (THB)', label: 'THB' },
-  { text: 'RM (MYR)', label: 'MYR' }
-];
-
-export const enum LOCALE_FORMATS {
-  DECIMAL = 'Decimal',
-  CURRENCY = 'Currency',
-  PERCENTAGE = 'Percentage',
-  SCIENTIFIC = 'Scientific',
-  ABBREVIATED = 'Abbreviated'
-}
-export const enum LOCALE_STYLES {
-  DECIMAL = 'decimal',
-  PERCENT = 'percent',
-  CURRENCY = 'currency',
-  SCIENTIFIC = 'scientific',
-  COMPACT = 'compact'
-}
-
-export const LANG_DEFAULT = 'en-US';
-export const CURRENCY_DEFAULT = { text: '$ (USD)', label: 'USD' };
-export const DATETIME_OPTIONS = { year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric' };
-
-export const PARTS_REGEX = /\[([^\]]+)]|Y{1,2}|M{1,2}|W{1,2}|D{1,2}|h{1,2}|H{1,2}|m{1,2}|s{1,2}|S{1,3}/g;
-
-export const DURATION_PARTS = {
-  S: { order: 1, symbol: "S", name: "milliseconds", ms: 1 },
-  s: { order: 2, symbol: "s", name: "seconds", ms: 1000 },
-  m: { order: 3, symbol: "m", name: "minutes", ms: 1000 * 60 },
-  h: { order: 4, symbol: "h", name: "hours", ms: 1000 * 60 * 60 },
-  H: { order: 5, symbol: "H", name: "hours", ms: 1000 * 60 * 60 },
-  D: { order: 6, symbol: "D", name: "days", ms: 1000 * 60 * 60 * 24 },
-  W: { order: 7, symbol: "W", name: "weeks", ms: 1000 * 60 * 60 * 24 * 7 },
-  M: { order: 8, symbol: "M", name: "months", ms: 1000 * 60 * 60 * 24 * 30 },
-  Y: { order: 9, symbol: "Y", name: "years", ms: 1000 * 60 * 60 * 24 * 365 },
-};
-
-export const DEFAULT_OPTIONS = {
-  unit: "seconds",
-  locale: "en-EN",
-  fractionDigits: 0
-};

package/src/format/duration/addDurationFormat.ts

@@ -1,17 +0,0 @@
-import { DurationFormatter } from "./durationFormatter";
-
-/**[TODO: The decimals dots are not working correctly, we need to reviewing (fractionDigits)]
- * "Convert a number of seconds to a human readable string."
- * 
- * `addDurationFormat` is a function that takes a number, a format, an optional locale, and an optional
- * number of fraction digits, and returns a string
- * @param {number} number - The number of milliseconds to format.
- * @param {string} format - The format string.
- * @param {string} [locale] - The locale to use for formatting. If not specified, the default locale is
- * used.
- * @param {number} [fractionDigits] - The number of digits to show after the decimal point.
- * @returns A string
- */
-export function addDurationFormat(number: number, format: string, locale?: string, fractionDigits?: number): string {
-  return new DurationFormatter( { template: format, options: { locale: locale, fractionDigits: fractionDigits } }).format(number);
-}

package/src/format/duration/durationFormatter.ts

@@ -1,169 +0,0 @@
-import { isEmpty } from "../../general/mix/isEmpty";
-import { DEFAULT_OPTIONS, DURATION_PARTS, PARTS_REGEX } from "../definition";
-
-/* It takes a template string and a number of milliseconds and returns a string that is formatted to
-the user's preference 
-this class is based on moment format:
-     years:   Y or y
-     months:  M
-     weeks:   W or w
-     days:    D or d
-     hours:   H or h
-     minutes: m
-     seconds: s
-     ms:      S
-*/
-export class DurationFormatter {
-    
-  private options: { unit?: string; locale?: string; fractionDigits?: number; };
-  private parts: any;
-  private valueFormatter: Intl.NumberFormat;
-  private numberFactor: number;
-  private template: string;
-  private numberFormatOptions = {
-    minimumFractionDigits: DEFAULT_OPTIONS.fractionDigits,
-    maximumFractionDigits: DEFAULT_OPTIONS.fractionDigits 
-  };
-
-  /**
-   * The constructor function takes in a template string and an options object. It then sets the
-   * options object to the default options object if no options object is passed in. It then parses
-   * the template string and sets the parts to the parsed template string. It then tries to set the
-   * valueFormatter to a new Intl.NumberFormat object with the locale and fractionDigits options. If
-   * it fails, it sets the valueFormatter to a new Intl.NumberFormat object with the default locale
-   * and fractionDigits options. It then sets the numberFactor to the duration parts object with the
-   * name of the unit option. If it can't find the unit option, it sets the numberFactor to 1
-   * @param [template] - The template string that will be used to format the duration.
-   * @param options - This is an object that contains the following properties: unit, locale and fractionDigits
-   */
-  constructor(options:{ template: string, options?: { unit?: string; locale?: string; fractionDigits?: number; }, intlNumberFormat?: Intl.NumberFormat }) {
-    this.setOptions(options.options);
-    this.setParts(options.template);
-    this.setLocaleFormatter(options.intlNumberFormat);
-    this.setNumberFactor();
-  }
-
-  private setOptions(options: { unit?: string; locale?: string; fractionDigits?: number; }){
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-  }
-
-  /**
-   * It sets the locale formatter for the number.
-   */
-  private setLocaleFormatter(intlNumberFormat: Intl.NumberFormat){
-    
-    try{
-      if(intlNumberFormat){
-        console.log(intlNumberFormat.resolvedOptions());
-        this.valueFormatter =  intlNumberFormat;
-      }else{
-        this.valueFormatter = this.getNewNumberFormat(this.options.locale);
-      }
-    }catch(e){
-      if(intlNumberFormat){
-        this.valueFormatter =  intlNumberFormat;
-      }else{
-        this.valueFormatter = this.getNewNumberFormat(DEFAULT_OPTIONS.locale);
-      }
-      
-    }
-  }
-
-  /**
-   * It returns a new instance of the Intl.NumberFormat class, which is a built-in JavaScript class
-   * that formats numbers
-   * @param {string | string[]} locale - string | string[]
-   * @returns A new instance of the Intl.NumberFormat class.
-   */
-  private getNewNumberFormat(locale: string | string[]){
-    return new Intl.NumberFormat(locale, this.numberFormatOptions);
-  }
-
-  /**
-   * It takes a template string and sets the parts property to the result of calling the
-   * parseFormatTemplate function with the template string as an argument
-   * @param {string} template - The format template string.
-   */
-  private setParts(template: string){
-    this.template = this.matchFormatsReplace(template);
-    this.parts = this.parseFormatTemplate(template);
-  }
-
-  /**
-   * It replaces the H and D characters in the template with h and d respectively
-   * @param {string} template - The template string to be used for the date format.
-   * @returns The template string with all instances of H replaced with h and all instances of D
-   * replaced with d.
-   */
-  private matchFormatsReplace(template: string){
-    return isEmpty(template) ? template: template.replace(/H/g, 'h');
-  }
-  
-  /**
-   * It sets the numberFactor to the value of the duration part that matches the unit.
-   */
-  private setNumberFactor(){
-    this.numberFactor = Object.values(DURATION_PARTS).find((d) => d.name === this.options.unit)?.ms || 1;
-  }
-  
-  /**
-   * It takes a string, splits it into an array of strings, then maps each string to a config object,
-   * then filters out any falsy values, then reverses the array
-   * @param {string} template - string - the template string that we want to parse
-   * @returns An array of objects that have the order and the name of the part of the duration.
-   */
-   private parseFormatTemplate(template: string) {
-    this.template = isEmpty(template)? '': template;
-    return (this.template.match(PARTS_REGEX) || [])
-      .reduce((store, part) => {
-        const config = DURATION_PARTS[part[0]];
-        if (config) store[config.order] = config;
-        return store;
-      }, [])
-      .filter(Boolean)
-      .reverse();
-  }
-
- 
-  
-   /**
-    * It takes a number, multiplies it by a factor, then uses the parts array to calculate the number
-    * of each part in the number, then uses the template to format the number
-    * @param {number} number - The number of milliseconds to format.
-    * @returns The template string with the values replaced.
-    */
-   public format(number: number): string {
-    if(number === null) return null;
-    if(number === undefined || this.template === undefined || isNaN(number)) return undefined;
-    if(isEmpty(number)) return "";
-
-    number *= this.numberFactor;
-
-    const durationParts = this.parts.reduce((store, part) => {
-      store[part.symbol] = number / part.ms;
-      number %= part.ms;
-      return store;
-    }, {});
-
-    if(!Number.isInteger(number)) return number === null? null: this.valueFormatter.format(number).padStart(this.parts.length, "0");
-    if(isEmpty(this.template)) return this.valueFormatter.format(number).padStart(this.parts.length, "0");
-
-    return this.template.replace(PARTS_REGEX, (match, $1) => {
-      return $1 || this.formatValue(durationParts, match);
-    });
-  }
-
- 
-  
-   /**
-    * It takes a dictionary of values and a list of keys, and returns a formatted string
-    * @param parts - { [x: string]: any; }
-    * @param {string | (string | number)[]} part - This is the part of the date that we're
-    * formatting.
-    * @returns The value of the part of the date that is being formatted.
-    */
-   private formatValue(parts: { [x: string]: any; }, part: string | (string | number)[]): string {
-    const value = parts[part[0]];
-    return this.valueFormatter.format(value).padStart(part.length, "0");
-  }
-}

package/src/format/duration/index.ts

@@ -1,2 +0,0 @@
-export * from './durationFormatter';
-export * from './addDurationFormat';

package/src/format/format.ts

@@ -1,293 +0,0 @@
-import { format as d3Format } from 'd3';
-import dayjs from 'dayjs';
-import { DATEGROUP_FORMATTING_UNSUPPORT, appliesFormatting, hasfileSizeProperty, isTextColumn } from './definition';
-import advancedFormat from 'dayjs/plugin/advancedFormat';
-import { isEmpty } from '../general/mix/isEmpty';
-import { _get } from '../general/object/get';
-import { COLUMN } from '../columns/constants/COLUMN';
-import { FORMULA } from '../formulas/constants/FORMULA';
-import { formatWithLocale } from './localization';
-import { isObject } from '../general/object/isObject';
-import { IFormatConfig } from '../interfaces/format/IFormatConfig.Interface';
-
-dayjs.extend(advancedFormat); // Add support to advanced formats https://day.js.org/docs/en/plugin/advanced-format
-
-/**
- * Apply to the given date format to a date value
- * @param bytes type number
- */
-function isValidDateString(dateString = '') {
-    return /^\d{2}\/\d{2}\/\d{4}/.test(dateString) // MM/DD/YYY OR DD/MM/YYYY
-        || /^\d{4}-\d{2}-\d{2}/.test(dateString);  // YYYY-MM-DD
-}
-
-export function formatDate(dateString, format) {
-    if(isObject(format)) format = format.format || "";
-    if (isEmpty(dateString) || !isNaN(dateString) || format === 'Default') return dateString;
-    if (!isValidDateString(dateString)) return dateString;
-    const dateValue = dateString?.replace(/Z$/i, '');
-    return dayjs(dateValue.split('.')[0]).format(format.replace('HH24:', 'HH:').replace('MI:SS', 'mm:ss').replace('MM:SS', 'mm:ss'));
-}
-
-export function formatAbbreviated(num, decimals) {
-    if (num == 0) return 0;
-
-    const absValue = Math.abs(num);
-    const exp = Math.floor(Math.log10(absValue));
-
-    if (exp <= 0 && exp >= -3)
-        return num.toFixed(decimals === 0 ? 2 : decimals);
-
-    return d3Format(num > -100 && num < 100 ? '.' + (decimals + 2) + 'n' : '.3s')(num);
-}
-
-function formatNumber(num, outputFormat, _config?) {
-    try {
-        num = +(num || 0);
-    } catch (e) {
-        num = 0;
-    }
-    if (isNaN(num)) num = 0;
-    const num_decimals = !isEmpty(outputFormat.decimals) && outputFormat.format !== 'Abbreviated' ? outputFormat.decimals : 0;
-
-    switch (outputFormat.format) {
-        case 'Abbreviated':
-            return formatAbbreviated(num, num_decimals);
-        case 'Numeric':
-        case 'Decimal':
-            return d3Format(`,.${num_decimals}f`)(num).replace(/\.(%*)$/, '$1');
-        case 'Currency': {
-
-            const currency = `${num < 0 ? '-' : ''} ${_get(outputFormat, 'currency.label', '$')}`;
-            const absNum = Math.abs(num);
-            return currency + d3Format(`,.${num_decimals}f`)(absNum).replace(/\.(%*)$/, '$1');
-        }
-        case 'Percentage':
-            return `${d3Format(`,.${num_decimals}f`)(num).replace(/\.(%*)$/, '$1')}%`;
-        case 'Scientific':
-            return Number(num).toExponential(num_decimals).replace('.00', '').replace('e+0', '');
-        default:
-            return `${num}`;
-    }
-}
-
-/**
- * Set convert Bytes into MB
- * @param bytes type number
- */
-export function formatFileSize(bytes: number): string {
-    const fixDecimals = (num) => {
-        return parseFloat(`${(num * 100) / 100}`).toFixed(2);
-    };
-
-    const kiloBytes = bytes / 1024;
-    if (kiloBytes < 1024) return `${fixDecimals(kiloBytes)} KB`;
-
-    const megaBytes = kiloBytes / 1024;
-    return megaBytes < 10 ? `${fixDecimals(megaBytes)} MB` : `${Math.round(megaBytes)} MB`;
-}
-
-export const addFormat = (value: any, outputFormat: any = 'None', config?: IFormatConfig): any => {
-  if (isEmpty(value) || typeof value === 'object' && isEmpty(value[0])) return value;
-  switch (outputFormat.type) {
-    case 'DATE':
-    case 'DATETIME':
-      return config?.lang && outputFormat.format === 'Default' ? formatWithLocale(value, outputFormat, config) : formatDate(value, outputFormat?.format === 'Default' && outputFormat?.originalFormat?.format ? outputFormat?.originalFormat?.format : outputFormat?.format);
-    case 'NUMERIC': {
-      const parse = parseFloat(value);
-      const withLocale = outputFormat !== 'None' && config?.lang;
-      return isNaN(parse) ? value : withLocale ? formatWithLocale(value, outputFormat, config)
-       : formatNumber(parse, outputFormat, config);
-    }
-    case 'IMAGEUPLOAD':
-    case 'FILEUPLOAD':
-      return formatFileSize(parseFloat(value));
-    default:
-      return typeof value === 'number' ? value.toFixed(0) : value;
-  }
-};
-
-export const parseFormulaType = (type: string) => {
-    switch (type) {
-        case FORMULA.NUMBER:
-            return 'NUMERIC';
-        case FORMULA.DATE:
-            return 'DATE';
-        default:
-            return 'TEXT_LABEL';
-    }
-};
-
-export const validateColumnType = (column) => {
-    if (!column) return;
-    return column.type === 'FORMULA' ? parseFormulaType(column.formulaType) : column.type;
-};
-
-export const defineFormat = (column: any = {}, isSimpleTable = false, isCategoryDimension?: boolean) => {
-    const isNumericAgg = (aggs) => !aggs.some(Agg => ['COUNT', 'DISTINCTCOUNT'].includes(Agg));
-    let columnType = validateColumnType(column);
-    columnType = isTextColumn(column) && ((column.outputFormat && column.outputFormat.type === 'NUMERIC') || (column.selectedFormat && column.selectedFormat.type === 'NUMERIC')) ? COLUMN.NUMERIC : columnType;
-    if (!appliesFormatting(columnType) && (isSimpleTable || !isSimpleTable && column.isGroup)) return 'None';
-    const outputFormat = _get(column, 'outputFormat.format');
-    const selectedFormat = _get(column, 'selectedFormat.format');
-    const outputType = _get(column, 'outputFormat.type');
-    const selectType = _get(column, 'selectedFormat.type');
-    const isNumericDefault = (_get(column, 'defaultFormat.format') === 'Default' || _get(column, 'defaultFormat.format') === 'Numeric') && _get(column, 'defaultFormat.type') === 'NUMERIC';
-    const isTable = isSimpleTable === true || (!isSimpleTable && (column.isGroup || column.groupAgg));
-    const isNumericDefaultOutput = !isTable && (outputFormat === 'Default' || outputFormat === 'Numeric') && outputType === 'NUMERIC';
-    const isNumericDefaultSelected = !isTable && (selectedFormat === 'Default' || selectedFormat === 'Numeric') && _get(column, 'selectedFormat.type') === 'NUMERIC';
-    const defaultAbbreviated = {
-        type: 'NUMERIC',
-        format: 'Abbreviated'
-    };
-    
-    const dateGroupLabel = _get(column, 'dateGroup.label') || column.dateGroup;
-    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:
-            if (isTable) return 'None';
-            if (outputFormat) {
-                if (isNumericDefaultOutput) return defaultAbbreviated;
-                return column.outputFormat;
-            }
-            if (selectedFormat) {
-                if (isNumericDefaultSelected) return defaultAbbreviated;
-                return column.selectedFormat;
-            }
-        break;
-        case COLUMN.DATE:
-            if ((!isTable && column.isSummary) || column.isXY) {
-                if (isCategoryDimension && outputFormat !== 'Default') return column.outputFormat;
-                if (!isCategoryDimension && outputType !== 'DATE') return column.outputFormat;
-                return defaultAbbreviated;
-            }
-            if ((isCategoryDimension || isTable) && DATEGROUP_FORMATTING_UNSUPPORT.includes(dateGroupLabel)) return 'None';
-            if ((isCategoryDimension || isTable) && selectType == 'NUMERIC' && dateGroupLabel && outputType === 'DATE') return column.outputFormat;
-            if ((isCategoryDimension || isTable) && selectType == 'NUMERIC' && dateGroupLabel && outputType === 'NUMERIC') return _get(column, 'defaultFormat');
-            if (selectedFormat && selectedFormat != 'Default') {
-                if (isNumericDefaultSelected) return defaultAbbreviated;
-                return column.selectedFormat;
-            }
-            if (outputFormat) {
-                if ((isCategoryDimension || isTable) && outputType !== 'DATE') return _get(column, 'defaultFormat');
-                if (!isCategoryDimension && !isTable && outputType === 'DATE') return defaultAbbreviated;
-                return column.outputFormat;
-            }
-            if (selectedFormat) {
-                if (isNumericDefaultSelected) return defaultAbbreviated;
-                return column.selectedFormat;
-            }
-            return {
-                type: columnType,
-                format: 'MM/DD/YYYY'
-            };
-        case COLUMN.NUMERIC:
-        case COLUMN.RATING:
-        case COLUMN.SLIDEBAR: {
-            if (column.calculation && (column.calculation.value === 'PDIFF' || column.calculation.aggregate === 'PDIFF')) {
-                return {
-                    type: 'NUMERIC',
-                    format: 'Percentage'
-                };
-            }
-
-            const isValueColInSimpleTable = isSimpleTable && !column.isGroup && !column.isSummary;
-            const isValidValueColInGroupedTable = !isSimpleTable && !column.isGroup && !column.isSummary && column.groupAgg && isNumericAgg([column.groupAgg]);
-
-            if (isValueColInSimpleTable || isValidValueColInGroupedTable || column.isGroup) {
-                if (isCategoryDimension === true) {
-                    if (isNumericDefault) return defaultAbbreviated;
-                    return _get(column, 'defaultFormat');
-                }
-
-                if (selectedFormat && selectedFormat != 'Default') {
-                    if (isNumericDefaultSelected) return defaultAbbreviated;
-                    return column.selectedFormat;
-                }
-                
-                if (outputFormat) {
-                    if (isNumericDefaultOutput) return defaultAbbreviated;
-                    return column.outputFormat;
-                }
-                
-                return {
-                    type: 'NUMERIC',
-                    format: 'Numeric'
-                };
-            }
-
-            const isValidSummarySimpleTable = column.isSummary && isSimpleTable && isNumericAgg([column.summaryType]);
-            const isValidSummaryGroupedTable = !isSimpleTable && (column.groupAgg || column.summaryType) && (isNumericAgg([column.groupAgg, column.summaryType])
-                || column.selectedFormat && column.selectedFormat.format !== 'Default');
-
-            if ((isValidSummarySimpleTable || isValidSummaryGroupedTable) && outputFormat) return column.outputFormat;
-            if (outputFormat) {
-                if (isNumericDefaultOutput) return defaultAbbreviated;
-                return column.outputFormat;
-            }
-            if (selectedFormat) {
-                if (isNumericDefaultSelected) return defaultAbbreviated;
-                return column.selectedFormat;
-            }
-            return {
-                type: 'NUMERIC',
-                format: 'Numeric'
-            };
-        }
-        case COLUMN.IMAGEUPLOAD:
-        case COLUMN.FILEUPLOAD:
-            if (hasfileSizeProperty(column)) {
-                if (column.calculation && column.calculation.value === 'PDIFF') {
-                    return {
-                        type: 'NUMERIC',
-                        format: 'Percentage'
-                    };
-                }
-
-                if (column.isGroup) {
-                    return {
-                        type: columnType,
-                        format: 'fileSize'
-                    };
-                }
-
-                if ((column.groupAgg || column.summaryType) && isNumericAgg([column.groupAgg, column.summaryType])) {
-                    return {
-                        type: columnType,
-                        format: 'fileSize'
-                    };
-                } else {
-                    if (outputFormat !== 'Default') return column.outputFormat;
-                    return {
-                        type: 'NUMERIC',
-                        format: 'Numeric'
-                    };
-                }
-            }
-
-            if (column.isGroup) return 'None';
-            if (
-                ((column.selectedFormat &&
-                    column.selectedFormat.format !== "Default") ||
-                    (!isSimpleTable && column.isSummary)) &&
-                    _get(column, "outputFormat.format")
-            )
-                return column.outputFormat;
-            break;
-        default:
-            if ((column.selectedFormat && column.selectedFormat.format !== 'Default' ||
-                (!isSimpleTable && column.isSummary)) && outputFormat) return column.outputFormat;
-            return {
-                type: 'NUMERIC',
-                format: 'Numeric'
-            };
-    }
-};

package/src/format/index.ts

@@ -1,3 +0,0 @@
-export * from './format';
-export * from './localization';
-export * from './duration/index';