@adaptabletools/adaptable 10.0.0-canary.0

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptableHelper = exports.addAdaptableObjectUuidAndSource = exports.runAdaptableComparerFunction = exports.checkAdaptableOptions = exports.getAppropriateAccessLevel = exports.AdaptableObjectExistsInState = exports.checkValidPrimaryKey = exports.initPredefinedConfigWithUuids = exports.assignadaptableOptions = void 0;
+const tslib_1 = require("tslib");
+const cloneDeepWith_1 = tslib_1.__importDefault(require("lodash-es/cloneDeepWith"));
+const isPlainObject_1 = tslib_1.__importDefault(require("lodash-es/isPlainObject"));
+const LoggingHelper_1 = require("./LoggingHelper");
+const Uuid_1 = require("../../PredefinedConfig/Uuid");
+const DefaultAdaptableOptions_1 = require("../Defaults/DefaultAdaptableOptions");
+function assignadaptableOptions(adaptableOptions) {
+    var _a, _b;
+    const returnadaptableOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions, adaptableOptions);
+    returnadaptableOptions.adaptableStateKey = (_a = returnadaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnadaptableOptions.adaptableId;
+    returnadaptableOptions.layoutOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
+    returnadaptableOptions.alertOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
+    returnadaptableOptions.entitlementOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.entitlementOptions, adaptableOptions.entitlementOptions);
+    returnadaptableOptions.alertOptions.flashingAlertDefaultProperties = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.alertOptions.flashingAlertDefaultProperties, (_b = adaptableOptions.alertOptions) === null || _b === void 0 ? void 0 : _b.flashingAlertDefaultProperties);
+    returnadaptableOptions.dashboardOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dashboardOptions, adaptableOptions.dashboardOptions);
+    returnadaptableOptions.editOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.editOptions, adaptableOptions.editOptions);
+    returnadaptableOptions.containerOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.containerOptions, adaptableOptions.containerOptions);
+    returnadaptableOptions.generalOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.generalOptions, adaptableOptions.generalOptions);
+    returnadaptableOptions.searchOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.searchOptions, adaptableOptions.searchOptions);
+    returnadaptableOptions.userInterfaceOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions, adaptableOptions.userInterfaceOptions);
+    returnadaptableOptions.userInterfaceOptions.dateInputOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions.dateInputOptions, returnadaptableOptions.userInterfaceOptions.dateInputOptions);
+    returnadaptableOptions.menuOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.menuOptions, adaptableOptions.menuOptions);
+    //  returnadaptableOptions.userInterfaceOptions.dateInputOptions = Object.assign(
+    //    {},
+    //    DefaultAdaptableOptions.userInterfaceOptions.dateInputOptions,
+    //    adaptableOptions.userInterfaceOptions.dateInputOptions
+    //  );
+    returnadaptableOptions.stateOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.stateOptions, adaptableOptions.stateOptions);
+    returnadaptableOptions.exportOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.exportOptions, adaptableOptions.exportOptions);
+    returnadaptableOptions.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
+    returnadaptableOptions.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
+    const { predefinedConfig } = returnadaptableOptions;
+    if (predefinedConfig) {
+        returnadaptableOptions.predefinedConfig =
+            typeof predefinedConfig === 'string'
+                ? predefinedConfig
+                : initPredefinedConfigWithUuids(predefinedConfig);
+    }
+    return returnadaptableOptions;
+}
+exports.assignadaptableOptions = assignadaptableOptions;
+function initPredefinedConfigWithUuids(predefinedConfig) {
+    const customizer = (value) => {
+        // so whenever we clone a plain object,
+        // we add a Uuid property
+        // jw added 9/8/20: unless there is on there already
+        if (isPlainObject_1.default(value) && value != predefinedConfig) {
+            if (value.Uuid == null || value.Uuid == undefined) {
+                value.Uuid = Uuid_1.createUuid();
+            }
+        }
+    };
+    return cloneDeepWith_1.default(predefinedConfig, customizer);
+}
+exports.initPredefinedConfigWithUuids = initPredefinedConfigWithUuids;
+function checkValidPrimaryKey(adaptable) {
+    const pkColumn = adaptable.api.columnApi.getColumnFromId(adaptable.adaptableOptions.primaryKey);
+    if (pkColumn == undefined && !adaptable.adaptableOptions.autogeneratePrimaryKey) {
+        const errorMessage = `The Primary Key Column '${adaptable.adaptableOptions.primaryKey}' does not exist.  This will affect many functions in Adaptable.`;
+        if (adaptable.adaptableOptions.generalOptions.showMissingPrimaryKeyAlert == true) {
+            // show an alert if that is the option
+            adaptable.api.alertApi.showAlertError('No Primary Key', errorMessage);
+        }
+        else {
+            if (adaptable.adaptableOptions.generalOptions.showMissingColumnsWarning == true) {
+                LoggingHelper_1.ConsoleLogError(errorMessage);
+            }
+        }
+        return false;
+    }
+    return true;
+}
+exports.checkValidPrimaryKey = checkValidPrimaryKey;
+function AdaptableObjectExistsInState(array, itemToCheck) {
+    if (array == null) {
+        return false;
+    }
+    return array.findIndex((abObject) => abObject.Uuid == itemToCheck.Uuid) > -1;
+}
+exports.AdaptableObjectExistsInState = AdaptableObjectExistsInState;
+function getAppropriateAccessLevel(adaptableObject, moduleAccessLevel) {
+    // we always return the Module Access Level unless the following condition is met:
+    // the object prpoerty has been set and set to true and the Module entitlement is full
+    if (moduleAccessLevel == 'Full' &&
+        adaptableObject &&
+        adaptableObject.IsReadOnly &&
+        adaptableObject.IsReadOnly == true) {
+        return 'ReadOnly';
+    }
+    return moduleAccessLevel;
+}
+exports.getAppropriateAccessLevel = getAppropriateAccessLevel;
+// perform any checks that are necessary here
+// for now just adaptableId
+function checkAdaptableOptions(adaptableOptions) {
+    if (adaptableOptions.adaptableId) {
+        if (adaptableOptions.adaptableId.includes('.')) {
+            LoggingHelper_1.ConsoleLogWarning("The 'adaptableId' property in adaptableOptions should not include a '.'.  We strongly recommend that you remove this.");
+        }
+    }
+}
+exports.checkAdaptableOptions = checkAdaptableOptions;
+function runAdaptableComparerFunction(columnId, columnValues, adaptable) {
+    return function compareItemsOfCustomSort(valueA, valueB, nodeA, nodeB) {
+        let firstElementValueString = nodeA
+            ? adaptable.getDisplayValueFromRowNode(nodeA, columnId)
+            : valueA;
+        let secondElementValueString = nodeB
+            ? adaptable.getDisplayValueFromRowNode(nodeB, columnId)
+            : valueB;
+        let indexFirstElement = columnValues.indexOf(firstElementValueString);
+        let containsFirstElement = indexFirstElement >= 0;
+        let indexSecondElement = columnValues.indexOf(secondElementValueString);
+        let containsSecondElement = indexSecondElement >= 0;
+        //if none of the element are in the list we jsut return normal compare
+        if (!containsFirstElement && !containsSecondElement) {
+            if (valueA == valueB) {
+                return 0;
+            }
+            return valueA < valueB ? -1 : 1;
+        }
+        //if first item not in the list make sure we put it after the second item
+        if (!containsFirstElement) {
+            return 1;
+        }
+        //if second item not in the list make sure we put it after the first item
+        if (!containsSecondElement) {
+            return -1;
+        }
+        //return the comparison from the list if the two items are in the list
+        return indexFirstElement - indexSecondElement;
+    };
+}
+exports.runAdaptableComparerFunction = runAdaptableComparerFunction;
+function addAdaptableObjectUuidAndSource(adaptableObject) {
+    if (!adaptableObject.Uuid) {
+        adaptableObject.Uuid = Uuid_1.createUuid();
+    }
+    adaptableObject.Source = 'User';
+    return adaptableObject;
+}
+exports.addAdaptableObjectUuidAndSource = addAdaptableObjectUuidAndSource;
+exports.AdaptableHelper = {
+    assignadaptableOptions,
+    initPredefinedConfigWithUuids,
+    checkValidPrimaryKey,
+    AdaptableObjectExistsInState,
+    checkAdaptableOptions,
+    runAdaptableComparerFunction,
+    getAppropriateAccessLevel,
+    addUuidAndSource: addAdaptableObjectUuidAndSource,
+};
+exports.default = exports.AdaptableHelper;

package/src/Utilities/Helpers/CalendarHelper.d.ts

@@ -0,0 +1,25 @@
+export declare const TODAY = "Today";
+export declare const YESTERDAY = "Yesterday";
+export declare const TOMORROW = "Tomorrow";
+export declare const PREVIOUS_WORK_DAY = "Previous Work Day";
+export declare const NEXT_WORK_DAY = "Next Work Day";
+export interface Calendar {
+    Name: string;
+    YearName: Number;
+    CalendarEntries: CalendarEntry[];
+}
+export interface CalendarEntry {
+    HolidayName: string;
+    HolidayDate: string;
+}
+export declare function getDynamicDate(dynamicDateName: string): Date;
+export declare function getNextWorkingDay(days?: number): Date;
+export declare function getPreviousWorkingDay(days?: number): Date;
+export declare function isNotWorkingDay(dateToCheck: Date): Boolean;
+export declare const CalendarHelper: {
+    getDynamicDate: typeof getDynamicDate;
+    getNextWorkingDay: typeof getNextWorkingDay;
+    getPreviousWorkingDay: typeof getPreviousWorkingDay;
+    isNotWorkingDay: typeof isNotWorkingDay;
+};
+export default CalendarHelper;

package/src/Utilities/Helpers/CalendarHelper.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarHelper = exports.isNotWorkingDay = exports.getPreviousWorkingDay = exports.getNextWorkingDay = exports.getDynamicDate = exports.NEXT_WORK_DAY = exports.PREVIOUS_WORK_DAY = exports.TOMORROW = exports.YESTERDAY = exports.TODAY = void 0;
+exports.TODAY = 'Today';
+exports.YESTERDAY = 'Yesterday';
+exports.TOMORROW = 'Tomorrow';
+exports.PREVIOUS_WORK_DAY = 'Previous Work Day';
+exports.NEXT_WORK_DAY = 'Next Work Day';
+function getAvailableCalendars() {
+    return [
+        {
+            Name: 'United Kingdom',
+            YearName: 2020,
+            CalendarEntries: [
+                { HolidayName: "New Year's Day", HolidayDate: new Date('January 01, 2020').toJSON() },
+                { HolidayName: 'Good Friday', HolidayDate: new Date('April 10, 2020').toJSON() },
+                { HolidayName: 'Easter Monday', HolidayDate: new Date('April 13, 2020').toJSON() },
+                { HolidayName: 'Early May Bank Holiday', HolidayDate: new Date('May 8 2020').toJSON() },
+                { HolidayName: 'Spring Bank Holiday', HolidayDate: new Date('May 25, 2020').toJSON() },
+                { HolidayName: 'Summer Bank Holiday', HolidayDate: new Date('August 31, 2020').toJSON() },
+                { HolidayName: 'Christmas Day', HolidayDate: new Date('December 25, 2020').toJSON() },
+                { HolidayName: 'Boxing Day', HolidayDate: new Date('December 28, 2020').toJSON() },
+            ],
+        },
+        {
+            Name: 'Germany',
+            YearName: 2020,
+            CalendarEntries: [
+                { HolidayName: "New Year's Day", HolidayDate: new Date('January 01, 2020').toJSON() },
+                { HolidayName: 'Good Friday', HolidayDate: new Date('April 10, 2020').toJSON() },
+                { HolidayName: 'Easter Monday', HolidayDate: new Date('April 13, 2020').toJSON() },
+                { HolidayName: 'Labour Day', HolidayDate: new Date('May 01 2020').toJSON() },
+                { HolidayName: 'Ascension Day', HolidayDate: new Date('May 21 2020').toJSON() },
+                { HolidayName: 'Whit Monday', HolidayDate: new Date('June 01, 2020').toJSON() },
+                { HolidayName: 'German Unity Day', HolidayDate: new Date('October 03, 2020').toJSON() },
+                { HolidayName: 'Christmas Day', HolidayDate: new Date('December 25, 2020').toJSON() },
+                { HolidayName: "St Stephen's Day", HolidayDate: new Date('December 26, 2020').toJSON() },
+            ],
+        },
+        {
+            Name: 'France',
+            YearName: 2020,
+            CalendarEntries: [
+                { HolidayName: 'New Years Day', HolidayDate: new Date('January 01, 2020').toJSON() },
+                { HolidayName: 'Easter Monday', HolidayDate: new Date('April 13, 2020').toJSON() },
+                { HolidayName: 'Labour Day', HolidayDate: new Date('May 01, 2020').toJSON() },
+                { HolidayName: 'VE Day', HolidayDate: new Date('May 08, 2020').toJSON() },
+                { HolidayName: 'Ascension Day', HolidayDate: new Date('May 21, 2020').toJSON() },
+                { HolidayName: 'Whitmonday', HolidayDate: new Date('June 01, 2020').toJSON() },
+                { HolidayName: 'Bastille Day', HolidayDate: new Date('July 14, 2020').toJSON() },
+                { HolidayName: 'Assumption Day', HolidayDate: new Date('August 15, 2020').toJSON() },
+                { HolidayName: 'All Saints Day', HolidayDate: new Date('November 01, 2020').toJSON() },
+                { HolidayName: 'Armistice Day', HolidayDate: new Date('November 11, 2020').toJSON() },
+                { HolidayName: 'Christmas Day', HolidayDate: new Date('December 25, 2020').toJSON() },
+            ],
+        },
+        {
+            Name: 'United States',
+            YearName: 2020,
+            CalendarEntries: [
+                { HolidayName: 'New Years Day', HolidayDate: new Date('January 01, 2020').toJSON() },
+                {
+                    HolidayName: 'Martin Luther King Day',
+                    HolidayDate: new Date('January 20, 2020').toJSON(),
+                },
+                { HolidayName: 'Presidents Day', HolidayDate: new Date('February 17, 2020').toJSON() },
+                { HolidayName: 'Memorial Day', HolidayDate: new Date('May 25, 2020').toJSON() },
+                { HolidayName: 'Independence Day', HolidayDate: new Date('July 03, 2020').toJSON() },
+                { HolidayName: 'Labour Day', HolidayDate: new Date('September 07, 2020').toJSON() },
+                { HolidayName: 'Columbus Day', HolidayDate: new Date('October 12, 2020').toJSON() },
+                { HolidayName: 'Veterans Day', HolidayDate: new Date('November 11, 2020').toJSON() },
+                { HolidayName: 'Thanksgiving Day', HolidayDate: new Date('November 26, 2020').toJSON() },
+                { HolidayName: 'Christmas Day', HolidayDate: new Date('December 25, 2020').toJSON() },
+            ],
+        },
+        {
+            Name: 'Canada',
+            YearName: 2020,
+            CalendarEntries: [
+                { HolidayName: 'New Years Day', HolidayDate: new Date('January 01, 2020').toJSON() },
+                { HolidayName: 'Good Friday', HolidayDate: new Date('April 10, 2020').toJSON() },
+                { HolidayName: 'Victoria Day', HolidayDate: new Date('May 18, 2020').toJSON() },
+                { HolidayName: 'Canada Day', HolidayDate: new Date('July 01, 2020').toJSON() },
+                { HolidayName: 'Labour Day', HolidayDate: new Date('September 07, 2020').toJSON() },
+                { HolidayName: 'Thanksgiving', HolidayDate: new Date('October 12, 2020').toJSON() },
+                { HolidayName: 'Rememberance Day', HolidayDate: new Date('November 11, 2020').toJSON() },
+                { HolidayName: 'Christmas Day', HolidayDate: new Date('December 25, 2020').toJSON() },
+                { HolidayName: 'Boxing Day', HolidayDate: new Date('December 26, 2020').toJSON() },
+            ],
+        },
+        {
+            Name: 'Singapore',
+            YearName: 2020,
+            CalendarEntries: [
+                { HolidayName: 'New Years Day', HolidayDate: new Date('January 01, 2020').toJSON() },
+                { HolidayName: 'Chinese New Year', HolidayDate: new Date('January 25, 2020').toJSON() },
+                { HolidayName: 'Good Friday', HolidayDate: new Date('April 10, 2020').toJSON() },
+                { HolidayName: 'Labour Day', HolidayDate: new Date('May 01, 2020').toJSON() },
+                { HolidayName: 'Vesak Day', HolidayDate: new Date('May 07, 2020').toJSON() },
+                { HolidayName: 'National Day', HolidayDate: new Date('August 09, 2020').toJSON() },
+                { HolidayName: 'Hari Raya Haji', HolidayDate: new Date('August 10, 2020').toJSON() },
+                { HolidayName: 'Deewali', HolidayDate: new Date('November 14, 2020').toJSON() },
+                { HolidayName: 'Christmas Day', HolidayDate: new Date('December 25, 2020').toJSON() },
+            ],
+        },
+    ];
+}
+function getDynamicDate(dynamicDateName) {
+    // eventually we should use some kind of enum? or class that holds this
+    let dynamicDate;
+    if (dynamicDateName == exports.TODAY) {
+        dynamicDate = new Date();
+    }
+    else if (dynamicDateName == exports.YESTERDAY) {
+        dynamicDate = new Date();
+        dynamicDate.setDate(dynamicDate.getDate() - 1);
+    }
+    else if (dynamicDateName == exports.TOMORROW) {
+        dynamicDate = new Date();
+        dynamicDate.setDate(dynamicDate.getDate() + 1);
+    }
+    else if (dynamicDateName == exports.PREVIOUS_WORK_DAY) {
+        dynamicDate = this.getPreviousWorkingDay(1);
+    }
+    else if (dynamicDateName == exports.NEXT_WORK_DAY) {
+        dynamicDate = this.getNextWorkingDay(1);
+    }
+    return dynamicDate;
+}
+exports.getDynamicDate = getDynamicDate;
+function getNextWorkingDay(days = 1) {
+    let count = 0;
+    let counterDate = new Date();
+    while (count < days) {
+        counterDate.setDate(counterDate.getDate() + 1);
+        if (this.isNotWorkingDay(counterDate)) {
+            count++;
+        }
+    }
+    return counterDate;
+}
+exports.getNextWorkingDay = getNextWorkingDay;
+function getPreviousWorkingDay(days = 1) {
+    let count = 0;
+    let counterDate = new Date();
+    while (count < days) {
+        counterDate.setDate(counterDate.getDate() - 1);
+        if (this.isNotWorkingDay(counterDate)) {
+            count++;
+        }
+    }
+    return counterDate;
+}
+exports.getPreviousWorkingDay = getPreviousWorkingDay;
+// pretty sure this can be improved as pretty expensive - though rarely used to be honest
+function isNotWorkingDay(dateToCheck) {
+    let currentCalendar = this.getGeneralOptions().currentCalendar;
+    let currentHoliday = getAvailableCalendars().find((c) => c.Name == currentCalendar);
+    for (let holiday of currentHoliday.CalendarEntries) {
+        let holidayDate = new Date(holiday.HolidayDate);
+        if (holidayDate.setHours(0, 0, 0, 0) == dateToCheck.setHours(0, 0, 0, 0)) {
+            return false;
+        }
+    }
+    return dateToCheck.getDay() != 0 && dateToCheck.getDay() != 6;
+}
+exports.isNotWorkingDay = isNotWorkingDay;
+exports.CalendarHelper = {
+    getDynamicDate,
+    getNextWorkingDay,
+    getPreviousWorkingDay,
+    isNotWorkingDay,
+};
+exports.default = exports.CalendarHelper;

package/src/Utilities/Helpers/DateHelper.d.ts

@@ -0,0 +1,4 @@
+export declare const isValidDate: (date: Date) => boolean;
+export declare const dateToISO: (date: Date | number | string) => string;
+export declare const parseToISO: (date: string | Date | number, dateFormat: string) => string;
+export declare const parseDate: (date: string, dateFormat: string) => Date | undefined;

package/src/Utilities/Helpers/DateHelper.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDate = exports.parseToISO = exports.dateToISO = exports.isValidDate = void 0;
+const tslib_1 = require("tslib");
+const parseISO_1 = tslib_1.__importDefault(require("date-fns/parseISO"));
+const parse_1 = tslib_1.__importDefault(require("date-fns/parse"));
+const LoggingHelper_1 = require("./LoggingHelper");
+const FormatHelper_1 = require("./FormatHelper");
+exports.isValidDate = (date) => {
+    return date instanceof Date && !isNaN(date.getTime());
+};
+exports.dateToISO = (date) => {
+    return FormatHelper_1.DateFormatter(date, { Pattern: 'yyyy-MM-dd' });
+};
+exports.parseToISO = (date, dateFormat) => {
+    let dateInstance = date instanceof Date
+        ? date
+        : typeof date === 'number'
+            ? new Date(date)
+            : exports.parseDate(date, dateFormat);
+    let valid = dateInstance && exports.isValidDate(dateInstance);
+    if (!valid) {
+        dateInstance = new Date(date);
+        valid = exports.isValidDate(dateInstance);
+    }
+    return valid ? exports.dateToISO(dateInstance) : '';
+};
+exports.parseDate = (date, dateFormat) => {
+    let d = parse_1.default(date, dateFormat, new Date());
+    if (!exports.isValidDate(d)) {
+        d = parseISO_1.default(date);
+    }
+    if (!exports.isValidDate(d)) {
+        LoggingHelper_1.LogAdaptableError(`Invalid date value "${date}" - cannot be converted to a Date instance. Please make sure you specify adaptableOptions.userInterfaceOptions.dateInputOptions.dateFormat correctly.`);
+        d = undefined;
+    }
+    return d;
+};

package/src/Utilities/Helpers/FormatHelper.d.ts

@@ -0,0 +1,11 @@
+import { NumberFormatterOptions, DateFormatterOptions, AdaptableFormat, StringFormatterOptions } from '../../PredefinedConfig/Common/AdaptableFormat';
+export declare function Format(input: any, format: AdaptableFormat): string;
+export declare function NumberFormatter(input: number, options?: NumberFormatterOptions): string;
+export declare function DateFormatter(input: number | Date | string, options: DateFormatterOptions): string | undefined;
+export declare function StringFormatter(input: string, options?: StringFormatterOptions): string;
+declare const _default: {
+    NumberFormatter: typeof NumberFormatter;
+    DateFormatter: typeof DateFormatter;
+    StringFormatter: typeof StringFormatter;
+};
+export default _default;

package/src/Utilities/Helpers/FormatHelper.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringFormatter = exports.DateFormatter = exports.NumberFormatter = exports.Format = void 0;
+const tslib_1 = require("tslib");
+// TODO inspect why the following is erroring on angular build
+// import dateFnsFormat from 'date-fns/format';
+const format_1 = tslib_1.__importDefault(require("date-fns/format"));
+const sentence_case_1 = require("sentence-case");
+function Format(input, format) {
+    if (format.Formatter === 'NumberFormatter') {
+        return NumberFormatter(input, format.Options);
+    }
+    if (format.Formatter === 'DateFormatter') {
+        return DateFormatter(input, format.Options);
+    }
+    throw new Error('Unknown formatter');
+}
+exports.Format = Format;
+function NumberFormatter(input, options = {}) {
+    if (input == null || input == undefined) {
+        return undefined;
+    }
+    let n = Number(input);
+    if (isNaN(n)) {
+        return undefined;
+    }
+    const fractionsSepatator = options.FractionSeparator ? options.FractionSeparator : '.';
+    let multiplier = options.Multiplier ? options.Multiplier : 1;
+    if (options.Multiplier !== undefined) {
+        n *= multiplier;
+        n = parseFloat(n.toFixed(12));
+    }
+    if (options.Parentheses === true && input < 0) {
+        n *= -1;
+        n = parseFloat(n.toFixed(12));
+    }
+    if (options.Truncate) {
+        n = Math.trunc(n);
+    }
+    let s;
+    let digitsToUse;
+    if (options.Truncate) {
+        digitsToUse = 0;
+    }
+    else if (options.FractionDigits != null) {
+        digitsToUse = options.FractionDigits;
+    }
+    else {
+        let decimalCount = Math.floor(n) === n ? 0 : n.toString().split(fractionsSepatator)[1].length || 0;
+        digitsToUse = decimalCount;
+    }
+    s = n.toLocaleString('en-US', {
+        minimumIntegerDigits: options.IntegerDigits || undefined,
+        minimumFractionDigits: digitsToUse,
+        maximumFractionDigits: digitsToUse,
+    });
+    if (options.FractionSeparator !== undefined) {
+        s = s.replace(/\./g, options.FractionSeparator);
+    }
+    if (options.IntegerSeparator !== undefined) {
+        s = s.replace(/\,/g, options.IntegerSeparator);
+    }
+    s = (options.Prefix || '') + s + (options.Suffix || '');
+    if (options.Parentheses === true && input < 0) {
+        s = '(' + s + ')';
+    }
+    return s;
+}
+exports.NumberFormatter = NumberFormatter;
+function DateFormatter(input, options) {
+    if (input == null || input == undefined) {
+        return undefined;
+    }
+    try {
+        if (typeof input === 'string') {
+            input = new Date(input);
+        }
+        return format_1.default(input, options.Pattern || '');
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+exports.DateFormatter = DateFormatter;
+function StringFormatter(input, options = {}) {
+    if (input == null || input == undefined) {
+        return undefined;
+    }
+    let s = input;
+    if (options.Case !== undefined) {
+        if (options.Case == 'Lower') {
+            s = s.toLowerCase();
+        }
+        else if (options.Case == 'Upper') {
+            s = s.toUpperCase();
+        }
+        else if (options.Case == 'Sentence') {
+            s = sentence_case_1.sentenceCase(s);
+        }
+    }
+    if (options.Trim !== undefined && options.Trim == true) {
+        s = s.trim();
+    }
+    return s;
+}
+exports.StringFormatter = StringFormatter;
+exports.default = { NumberFormatter, DateFormatter, StringFormatter };

package/src/Utilities/Helpers/Helper.d.ts

@@ -0,0 +1,38 @@
+export declare function objectExists(item: any): boolean;
+export declare function objectNotExists(item: any): boolean;
+export declare function getStringRepresentionFromKey(event: KeyboardEvent | any): string;
+export declare function cloneObject<T extends any>(obj: T): T;
+export declare const arrayToKeyMap: <T extends string | number | symbol>(arr?: T[]) => Record<T, boolean>;
+export declare function convertArrayToCsv(array: any[], separator?: string): string;
+export declare function createDownloadedFile(content: any, fileName: string, mimeType: string): void;
+export declare function copyToClipboard(text: string): boolean;
+export declare function ReturnItemCount(items: any[], itemName: string): string;
+export declare function IsInputNullOrEmpty(itemToCheck: any): boolean;
+export declare function IsInputNotNullOrEmpty(itemToCheck: any): boolean;
+export declare function RoundNumber(numberToRound: any, decimalPlaces: number): number;
+export declare function RoundNumberTo4dp(numberToRound: any): number;
+export declare function sumNumberArray(numericValues: number[]): number;
+export declare function meanNumberArray(numericValues: number[]): number;
+export declare function medianNumberArray(numericValues: number[]): number;
+export declare function modeNumberArray(numbers: number[]): number;
+export declare function clamp(value: any, boundOne: number, boundTwo: number): number;
+export declare const Helper: {
+    objectExists: typeof objectExists;
+    objectNotExists: typeof objectNotExists;
+    getStringRepresentionFromKey: typeof getStringRepresentionFromKey;
+    cloneObject: typeof cloneObject;
+    convertArrayToCsv: typeof convertArrayToCsv;
+    createDownloadedFile: typeof createDownloadedFile;
+    copyToClipboard: typeof copyToClipboard;
+    ReturnItemCount: typeof ReturnItemCount;
+    IsInputNullOrEmpty: typeof IsInputNullOrEmpty;
+    IsInputNotNullOrEmpty: typeof IsInputNotNullOrEmpty;
+    RoundNumber: typeof RoundNumber;
+    RoundNumberTo4dp: typeof RoundNumberTo4dp;
+    sumNumberArray: typeof sumNumberArray;
+    meanNumberArray: typeof meanNumberArray;
+    medianNumberArray: typeof medianNumberArray;
+    modeNumberArray: typeof modeNumberArray;
+    clamp: typeof clamp;
+};
+export default Helper;