@talxis/base-controls 1.2406.2 → 1.2406.4

package/src/components/Grid/core/enums/DataType.ts

@@ -1,25 +0,0 @@
-export enum DataType {
-    SINGLE_LINE_TEXT = 'SingleLine.Text',
-    SINGLE_LINE_TEXT_AREA = 'SingleLine.TextArea',
-    SINGLE_LINE_EMAIL = 'SingleLine.Email',
-    SINGLE_LINE_PHONE = 'SingleLine.Phone',
-    SINGLE_LINE_URL = 'SingleLine.URL',
-    MULTIPLE = 'Multiple',
-    WHOLE_NONE = 'Whole.None',
-    DECIMAL = 'Decimal',
-    FP = 'FP',
-    DATE_AND_TIME_DATE_AND_TIME = 'DateAndTime.DateAndTime',
-    DATE_AND_TIME_DATE_ONLY = 'DateAndTime.DateOnly',
-    CURRENCY = 'Currency',
-    OPTIONSET = 'OptionSet',
-    MULTI_SELECT_OPTIONSET = 'MultiSelectPicklist',
-    TWO_OPTIONS = 'TwoOptions',
-    LOOKUP_SIMPLE = 'Lookup.Simple',
-    LOOKUP_OWNER = 'Lookup.Owner',
-    // Not supported in pcf dataset - https://learn.microsoft.com/en-us/power-apps/developer/component-framework/manifest-schema-reference/property-set#value-elements-that-are-not-supported
-    WHOLE_LANGUAGE = 'Whole.Language',
-    WHOLE_DURATION = 'Whole.Duration',
-    WHOLE_TIMEZONE = 'Whole.TimeZone',
-    FILE = 'File',
-    IMAGE = 'Image',
-  }

package/src/components/Grid/core/hooks/useGridInstance.ts

@@ -1,7 +0,0 @@
-import { useContext } from "react"
-import { GridContext } from "../../Grid"
-import { Grid } from "../model/Grid";
-
-export const useGridInstance = (): Grid => {
-    return useContext(GridContext).gridInstance;
-}

package/src/components/Grid/core/hooks/useRefreshCallback.ts

@@ -1,20 +0,0 @@
-import { useEffect, useMemo } from "react";
-import { GridDependency } from "../model/GridDependency";
-
-export const useRefreshCallback = (model: GridDependency | Promise<GridDependency>, refreshCallback: () => any) => {
-    const id = useMemo(() => crypto.randomUUID(), [])
-    useEffect(() => {
-        (async () => {
-            const _model = await model;
-            _model.addRefreshCallback(id, refreshCallback);
-        })();
-        console.log('refresh callback added')
-        return () => {
-            (async () => {
-                const _model = await model;
-                _model.removeRefreshCallback(id);
-                
-            })();
-        }
-    }, []);
-};

package/src/components/Grid/core/hooks/useRerender.ts

@@ -1,15 +0,0 @@
-import { useEffect, useState } from "react"
-
-export const useRerender = (): [
-    number,
-    (fn?: () => any | Promise<any>) => void
-] => {
-    const [rerender, setRerender] = useState<number>(0);
-
-    const renderDecorator = async (fn?: () => any | Promise<any>) => {
-        await fn?.();
-        setRerender(c => c + 1);
-    }
-
-    return [rerender, renderDecorator];
-}

package/src/components/Grid/core/interfaces/IGridColumn.ts

@@ -1,19 +0,0 @@
-import { DataType } from "../enums/DataType";
-
-export interface IGridColumn {
-    key: string;
-    attributeName: string;
-    isPrimary?: boolean;
-    dataType?: DataType;
-    displayName?: string;
-    entityAliasName?: string;
-    isFilterable?: boolean;
-    isSortable?: boolean;
-    isSorted?: boolean;
-    isFiltered?: boolean;
-    isSortedDescending?: boolean;
-    isEditable?: boolean;
-    isResizable?: boolean;
-    isRequired?: boolean;
-    width?: number;
-}

package/src/components/Grid/core/interfaces/IGridContext.ts

@@ -1,7 +0,0 @@
-import { StringProps } from "../../../../types";
-import { IGrid, IGridTranslations } from "../../interfaces";
-import { Grid } from "../model/Grid";
-
-export interface IGridContext {
-    gridInstance: Grid;
-}

package/src/components/Grid/core/model/Grid.ts

@@ -1,250 +0,0 @@
-import { IDatasetProperty } from "../../../../interfaces";
-import { StringProps } from "../../../../types";
-import { Filtering } from "../../filtering/model/Filtering";
-import { IEntityColumn, IEntityRecord, IGrid, IGridTranslations } from "../../interfaces";
-import { Paging } from "../../paging/model/Paging";
-import { Selection } from "../../selection/model/Selection";
-import { Sorting } from "../../sorting/Sorting";
-import { DataType } from "../enums/DataType";
-import { IGridColumn } from "../interfaces/IGridColumn";
-import { RecordUpdateService } from "../services/RecordUpdateService/model/RecordUpdateService";
-import { Metadata } from "./Metadata";
-
-export class Grid {
-    private _props: IGrid;
-    private _dataset: IDatasetProperty
-    private _pcfContext: ComponentFramework.Context<any>;
-    private _columns: IGridColumn[] = [];
-    private _records: IEntityRecord[] = [];
-    private _labels: Required<StringProps<IGridTranslations>>;
-    private _shouldRerender: boolean = false;
-    //TODO: the dependencies might not have fully loaded grid
-    //need to make sure that the grid is initialized before creating them
-    private _dependencies: {
-        recordUpdateService: RecordUpdateService,
-        filtering: Filtering,
-        sorting: Sorting,
-        metadata: Metadata,
-        selection: Selection,
-        paging: Paging
-    };
-    constructor(props: IGrid, labels: Required<StringProps<IGridTranslations>>) {
-        this._props = props;
-        this._dataset = props.parameters.Grid;
-        this._pcfContext = props.context;
-        this._labels = labels;
-
-        this._dependencies = {
-            recordUpdateService: new RecordUpdateService(this),
-            filtering: new Filtering(this),
-            selection: new Selection(this),
-            metadata: new Metadata(this),
-            sorting: new Sorting(this),
-            paging: new Paging(this)
-        }
-
-    };
-    public get isNavigationEnabled() {
-        //enabled by default
-        return this.parameters.EnableNavigation?.raw !== false;
-    }
-    public get isEditable() {
-        return this._columns.find(x => x.isEditable) ? true : false;
-    }
-    public get parameters() {
-        return this._props.parameters
-    }
-    public get error() {
-        return this._dataset.error;
-    }
-    public get errorMessage() {
-        return this._dataset.errorMessage
-    }
-    public get labels() {
-        return this._labels;
-    }
-    public get dataset() {
-        return this._dataset;
-    }
-    public get pcfContext() {
-        return this._pcfContext;
-    }
-    public get props() {
-        return this._props;
-    }
-    public get columns() {
-        return this._columns;
-    }
-    public get records() {
-        return this._records;
-    }
-    public get recordUpdateService() {
-        return this._dependencies.recordUpdateService;
-    }
-    public get sorting() {
-        return this._dependencies.sorting;
-    }
-    public get metadata() {
-        return this._dependencies.metadata;
-    }
-    public get filtering() {
-        return this._dependencies.filtering;
-    }
-    public get selection() {
-        return this._dependencies.selection;
-    }
-    public get paging() {
-        return this._dependencies.paging;
-    }
-    public get shouldRerender() {
-        return this._shouldRerender;
-    }
-    public get loading() {
-        return this._dataset.loading;
-    }
-    public get state() {
-        return this._props.state;
-    }
-    public get isNested() {
-        return this.parameters.IsNested?.raw === true;
-    }
-
-    public openDatasetItem(entityReference: ComponentFramework.EntityReference) {
-        const clickedRecord = this._records.find(x => x.getRecordId() === entityReference.id.guid);
-        //we need to make sure the item we are opening gets selected in order for the
-        //OnOpenRecord ribbon scripts to work correctly
-        //if no record found we have clicked a lookup, no selection should be happening in that case
-        if (clickedRecord) {
-            this.selection.toggle(clickedRecord, true, true, true);
-        }
-        this._dataset.openDatasetItem(entityReference);
-    }
-
-    public updateDependencies(props: IGrid): void {
-        this._props = props;
-        this._dataset = props.parameters.Grid;
-        this._pcfContext = props.context;
-        for (const [key, dependency] of Object.entries(this._dependencies)) {
-            dependency.onDependenciesUpdated()
-        }
-        this._shouldRerender = !this.shouldRerender;
-    }
-    public async refreshColumns(): Promise<IGridColumn[]> {
-        const gridColumns: IGridColumn[] = [];
-        for (const column of this._dataset.columns) {
-            const sorted = this._dataset.sorting?.find(sort => sort.name === column.name);
-            const entityAliasName = column.name?.includes('.') ? column.name.split('.')[0] : null;
-            const attributeName = entityAliasName ? column.name.split('.')[1] : column.name;
-            switch (column.dataType) {
-                case DataType.FILE:
-                case DataType.IMAGE: {
-                    if (entityAliasName) {
-                        //we do not support file fields with linked entities
-                        //the getValue API throws an error in Power Apps
-                        continue;
-                    }
-                }
-            }
-            const gridColumn = {
-                entityAliasName: entityAliasName,
-                attributeName: attributeName,
-                key: entityAliasName ? `${entityAliasName}.${attributeName}` : attributeName,
-                isPrimary: column.isPrimary,
-                dataType: column.dataType as DataType,
-                displayName: column.displayName,
-                //comes from extended
-                isFilterable: this._isColumnFilterable(column),
-                isRequired: column.isRequired,
-                isSortable: this._isColumnSortable(column),
-                isSorted: sorted ? true : false,
-                isSortedDescending: sorted?.sortDirection === 1 ? true : false,
-                width: column.visualSizeFactor,
-                //comes from extended
-                isResizable: column.isResizable ?? true,
-            } as IGridColumn;
-
-            const condition = await this.filtering.condition(gridColumn);
-            gridColumn.isFiltered = condition.isAppliedToDataset;
-            gridColumn.isEditable = await this._isColumnEditable(gridColumn);
-            gridColumn.isRequired = await this._isColumnRequired(gridColumn);
-
-            if (gridColumn.displayName?.startsWith('__ribbon')) {
-                gridColumn.key = '__ribbon',
-                    gridColumn.displayName.split('__ribbon$')?.[1]
-                gridColumn.isFilterable = false;
-                gridColumn.isSortable = false;
-            }
-            gridColumns.push(gridColumn);
-        }
-        if(this.selection.type !== undefined) {
-            gridColumns.unshift({
-                key: '__checkbox',
-                attributeName: '__checkbox',
-                width: 45,
-            })
-        }
-        this._columns = gridColumns;
-        return gridColumns;
-    }
-
-    public refreshRecords(): IEntityRecord[] {
-        const records = [];
-        for (const [_, record] of Object.entries(this._dataset.records)) {
-            records.push(record);
-        }
-        this._records = records;
-        return records
-    }
-
-    private async _isColumnEditable(column: IGridColumn): Promise<boolean> {
-        //top priority, overriden through props
-        if (column.isEditable) {
-            return true;
-        }
-        //only allow editing if specifically allowed
-        if (!this._props.parameters.EnableEditing?.raw) {
-            return false;
-        }
-        //we are not supporting editing for linked entities
-        if (column.entityAliasName) {
-            return false;
-        }
-        //these field types do not support editing
-        switch (column.dataType) {
-            case DataType.FILE:
-            case DataType.IMAGE: {
-                return false;
-            }
-        }
-        const metadata = await this._pcfContext.utils.getEntityMetadata(this._dataset.getTargetEntityType(), [column.attributeName]);
-        //IsEditable is not available in Power Apps
-        return metadata.Attributes.get(column.attributeName).attributeDescriptor.IsValidForUpdate
-    }
-
-    private async _isColumnRequired(column: IGridColumn) {
-        if (column.isRequired) {
-            return true;
-        }
-        if (!this.parameters.EnableEditing?.raw) {
-            return false;
-        }
-        const metadata = await this.metadata.get(column);
-        const requiredLevel = metadata.Attributes.get(column.attributeName).attributeDescriptor.RequiredLevel;
-        if (requiredLevel === 1 || requiredLevel === 2) {
-            return true;
-        }
-        return false;
-    }
-    private _isColumnSortable(column: IEntityColumn) {
-        if (this._props.parameters.EnableSorting?.raw === false) {
-            return false;
-        }
-        return !column.disableSorting;
-    }
-    private _isColumnFilterable(column: IEntityColumn) {
-        if (this.props.parameters.EnableFiltering?.raw === false) {
-            return false;
-        }
-        return column.isFilterable ?? true;
-    }
-}

package/src/components/Grid/core/model/GridDependency.ts

@@ -1,34 +0,0 @@
-import { Grid } from "./Grid";
-
-export class GridDependency {
-    protected _grid: Grid;
-    protected _refreshCallbacks: Map<string, () => any> = new Map();
-    
-    constructor(grid: Grid) {
-        this._grid = grid;
-    }
-
-    public addRefreshCallback(id: string, callback: () => any) {
-        this._refreshCallbacks.set(id, callback);
-    }
-
-    public removeRefreshCallback(id: string) {
-        this._refreshCallbacks.delete(id);
-    }
-
-    public onDependenciesUpdated() {
-
-    }
-
-    protected _triggerRefreshCallbacks() {
-        for(const refreshCallback of this._refreshCallbacks.values()) {
-            refreshCallback();
-        }
-    }
-    protected get _dataset() {
-        return this._grid.dataset;
-    }
-    protected get _pcfContext() {
-        return this._grid.pcfContext;
-    }
-}

package/src/components/Grid/core/model/Metadata.ts

@@ -1,20 +0,0 @@
-import { IGridColumn } from "../interfaces/IGridColumn";
-import { GridDependency } from "./GridDependency";
-
-export class Metadata extends GridDependency {
-    public async get(column: IGridColumn): Promise<ComponentFramework.PropertyHelper.EntityMetadata> {
-        if(column.entityAliasName) {
-            const linkedEntity = this._grid.dataset.linking.getLinkedEntities().find(x => x.alias === column.entityAliasName)!;
-            return await this._grid.pcfContext.utils.getEntityMetadata(linkedEntity.name, [column.attributeName]);
-        }
-        else {
-            return await this._grid.pcfContext.utils.getEntityMetadata(this._grid.dataset.getTargetEntityType(), [column.attributeName]);
-        }
-    }
-    public async getOptions(column: IGridColumn): Promise<[number | boolean, ComponentFramework.PropertyHelper.OptionMetadata[]]> {
-        const columnMetadata = await this.get(column);
-        const options = columnMetadata.Attributes.get(column.attributeName).attributeDescriptor.OptionSet as ComponentFramework.PropertyHelper.OptionMetadata[]
-        const defaultValue = columnMetadata.Attributes.get(column.attributeName).DefaultFormValue as number | boolean;
-        return [defaultValue, options];
-    }
-}

package/src/components/Grid/core/services/RecordUpdateService/controllers/useRecordUpdateServiceController.ts

@@ -1,36 +0,0 @@
-import { useGridInstance } from "../../../hooks/useGridInstance";
-import { IUpdatedRecord } from "../model/RecordUpdateService";
-
-interface IRecordUpdateServiceController {
-    isDirty: boolean,
-    hasInvalidRecords: boolean
-    updatedRecords: IUpdatedRecord[];
-    saveAll: () => Promise<boolean>;
-    clearAll: () => void,
-    record(recordId: string): {
-        get: () => IUpdatedRecord | undefined
-        setValue: (columnName: string, value: any) => void
-    }
-}
-
-export const useRecordUpdateServiceController = (): IRecordUpdateServiceController => {
-    const grid = useGridInstance();
-    const recordUpdateService = grid.recordUpdateService;
-    
-    return {
-        isDirty: recordUpdateService.isDirty,
-        hasInvalidRecords: recordUpdateService.hasInvalidRecords,
-        updatedRecords: [...recordUpdateService.updatedRecords.values()],
-        saveAll: () => recordUpdateService.saveAll(),
-        clearAll: () => recordUpdateService.clearAll(),
-        record: (recordId: string) => {
-            const record = recordUpdateService.record(recordId);
-            return {
-                get: () => record.get(),
-                setValue: (columnName: string, value: any) => {
-                    record.setValue(columnName, value)
-                }   
-            }
-        }
-    }
-}

package/src/components/Grid/core/services/RecordUpdateService/model/RecordUpdateService.ts

@@ -1,222 +0,0 @@
-import equal from "fast-deep-equal/es6";
-import { cloneDeep } from "lodash";
-import numeral from "numeral";
-import { NumeralPCF } from "../../../../../../utils/NumeralPCF";
-import { IEntityColumn, IEntityRecord } from "../../../../interfaces";
-import { ColumnValidation } from "../../../../validation/model/ColumnValidation";
-import { DataType } from "../../../enums/DataType";
-import { Grid } from "../../../model/Grid";
-import { GridDependency } from "../../../model/GridDependency";
-
-export interface IUpdatedRecord extends Omit<IEntityRecord, 'save'> {
-    columns: Map<string, IEntityColumn>,
-    isValid: (columnKey: string) => boolean,
-    getOriginalValue: (columnKey: string) => any;
-    getOriginalFormattedValue: (columnKey: string) => any;
-    getOriginalFormattedPrimaryNameValue: () => any;
-    save: () => Promise<boolean>,
-    clear: () => void;
-}
-
-export class RecordUpdateService extends GridDependency {
-    private _updatedRecords: Map<string, IUpdatedRecord> = new Map();
-    private _internalRecordMap: Map<string, IEntityRecord> = new Map();
-
-    constructor(grid: Grid) {
-        super(grid);
-        const updatedRecordsFromState: IUpdatedRecord[] | undefined = this._grid.state?.['__updatedRecords'];
-        //@ts-ignore - getRecordId could be undefined if it comes from serialized state
-        if(updatedRecordsFromState && updatedRecordsFromState?.length > 0 && updatedRecordsFromState[0].getRecordId) {
-            this._updatedRecords = new Map(updatedRecordsFromState.map(x => {
-                const originalClear = x.clear;
-                const originalSetValue = x.setValue;
-                const originalSave = x.save;
-                x.clear = () => {
-                    this._updatedRecords.delete(x.getRecordId());
-                    originalClear();
-                    this._pcfContext.factory.requestRender();
-                }
-                x.save = async () => {
-                    const result = await originalSave();
-                    if(result) {
-                        this._updatedRecords.delete(x.getRecordId());
-                    }
-                    [...x.columns.values()].map(col =>  {
-                        this._internalRecordMap.get(x.getRecordId())?.setValue(col.name, x.getValue(col.name));
-                    })
-                    return result;
-                }
-                x.setValue = (columnName: string, value: any) => {
-                    originalSetValue(columnName, value);
-                    this._pcfContext.factory.requestRender();
-                }
-                return [x.getRecordId(), x]
-            }))
-        }
-    }
-
-    public get updatedRecords() {
-        if (this._isReadOnlyChangeEditor() && this._updatedRecords.size === 0) {
-            const record = this._grid.records[0];
-            for (const column of this._grid.columns) {
-                this.record(record.getRecordId()).setValue(column.key, record.getValue(column.key), true);
-            }
-        }
-        return [...this._updatedRecords.values()];
-    }
-
-    public get isDirty() {
-        return this._updatedRecords.size > 0;
-    }
-
-    public get hasInvalidRecords() {
-        return [...this._updatedRecords.values()].find(x => {
-            for(const column of x.columns.values()) {
-                if(!x.isValid(column.name)) {
-                    return true;
-                }
-            }
-            return false;
-        }) ? true : false;
-    }
-
-    public record(recordId: string) {
-        return {
-            get: () => this._updatedRecords.get(recordId),
-            setValue: (columnKey: string, value: any, doNotPropagateToDatasetRecord?: boolean) => {
-                if(!doNotPropagateToDatasetRecord && this._isEqual(columnKey, this._internalRecordMap.get(recordId)!.getValue(columnKey), value)) {
-                    return;
-                }
-                const updatedRecord = this._updatedRecords.get(recordId);
-                if (!updatedRecord) {
-                    const deepCopiedRecord = cloneDeep(this._internalRecordMap.get(recordId)!);
-                    this._updatedRecords.set(recordId, {
-                        columns: new Map([[columnKey, this._getEntityColumnByKey(columnKey)]]),
-                        getRecordId: () => recordId,
-                        getValue: (columnKey: string) => this._internalRecordMap.get(recordId)?.getValue(columnKey)!,
-                        getFormattedValue: (columnKey: string) => this._internalRecordMap.get(recordId)?.getFormattedValue(columnKey)!,
-                        getNamedReference: () => deepCopiedRecord.getNamedReference(),
-                        getOriginalValue: (columnKey: string) => deepCopiedRecord.getValue(columnKey),
-                        getOriginalFormattedValue: (columnKey: string) => deepCopiedRecord.getFormattedValue(columnKey),
-                        getOriginalFormattedPrimaryNameValue: () => {
-                            let primaryColumn = this._dataset.columns.find(x => x.isPrimary);
-                            if(!primaryColumn) {
-                                primaryColumn = this._dataset.columns[0];
-                            }
-                            let value = deepCopiedRecord.getFormattedValue(primaryColumn.name);
-                            if(!value) {
-                                value = this._grid.labels["no-name"]();
-                            }
-                            return value;
-                        },
-                        setValue: (columnKey: string, value: any) => {
-                            const updatedRecord = this._updatedRecords.get(recordId);
-                            let originalValue = updatedRecord?.getOriginalValue(columnKey);
-                            //if the new change is equal to the original record state, clear the internal dirty state
-                            if(originalValue == value || equal(value, originalValue)) {
-                                updatedRecord?.columns.delete(columnKey);
-                                if(updatedRecord?.columns.size === 0) {
-                                    this._updatedRecords.delete(recordId);
-                                }
-                            }
-                            this._internalRecordMap.get(recordId)?.setValue(columnKey, value);
-                        },
-                        isValid: (columnKey: string) => {
-                            const column = this._grid.columns.find(x => x.key === columnKey);
-                            if(!column) {
-                                return true;
-                            }
-                            const [result, message] = new ColumnValidation(this._grid, column).validate(this._internalRecordMap.get(recordId)?.getValue(columnKey)!)
-                            return result;
-                        },
-                        clear: () => {
-                            const updatedRecord = this._updatedRecords.get(recordId);
-                            const columns = [...updatedRecord!.columns.values()];
-                            this._updatedRecords.delete(recordId);
-                            for(const column of columns) {
-                                this._internalRecordMap.get(recordId)?.setValue(column.name, deepCopiedRecord.getValue(column.name));
-                            }
-                        },
-                        save: async () => {
-                            try {
-                                await this._internalRecordMap.get(recordId)?.save();
-                                this._updatedRecords.delete(recordId);
-                            }
-                            catch (err) {
-                                this._grid.pcfContext.navigation.openErrorDialog({
-                                    message: 'An error occurred during saving. Some of you changes might now have been saved.',
-                                    //@ts-ignore
-                                    details: err.message
-                                })
-                                return false;
-                            }
-                            return true;
-                        }
-                    })
-                }
-                else {
-                    updatedRecord.columns.set(columnKey, this._getEntityColumnByKey(columnKey))
-                }
-                if (!doNotPropagateToDatasetRecord) {
-                    const updatedRecord = this._updatedRecords.get(recordId);
-                    if(this._isEqual(columnKey, updatedRecord?.getOriginalValue(columnKey)!, value)) {
-                        updatedRecord?.columns.delete(columnKey);
-                        if(updatedRecord?.columns.size === 0) {
-                            this._updatedRecords.delete(recordId);
-                        }
-                    }
-                    updatedRecord?.setValue(columnKey, value);
-                }
-            }
-        }
-    }
-
-    public async saveAll(): Promise<boolean> {
-        const savePromises: Promise<boolean>[] = [];
-        for (const record of this._updatedRecords.values()) {
-            savePromises.push(record.save());
-        }
-        const result = await Promise.all(savePromises);
-        return !result.find(x => x === false)
-    }
-    public async clearAll() {
-        for (const record of this._updatedRecords.values()) {
-            record.clear();
-        }
-    }
-
-    public onDependenciesUpdated(): void {
-        for (const [recordId, record] of Object.entries(this._grid.dataset.records)) {
-            this._internalRecordMap.set(recordId, record);
-        }
-    }
-    private _getEntityColumnByKey(columnKey: string) {
-        const gridColumn = this._grid.columns.find(x => x.key === columnKey)!;
-        return this._dataset.columns.find(x => {
-            if (!gridColumn.entityAliasName) {
-                return x.name === gridColumn.attributeName;
-            }
-            return x.name === gridColumn.attributeName && x.alias === gridColumn.entityAliasName;
-        })!;
-    }
-    private _isReadOnlyChangeEditor() {
-        return this._grid.props.parameters.ChangeEditorMode?.raw === 'read';
-    }
-    private _isEqual(columnKey: string, oldValue: any, newValue: any) {
-        const column = this._grid.columns.find(x => x.key === columnKey);
-        //skip in special case for currency
-        //PCF has no info about the currency, which sometimes make it to ouput change
-        if(column?.dataType === DataType.CURRENCY) {
-            NumeralPCF.currency(this._grid.pcfContext.userSettings.numberFormattingInfo);
-            newValue = numeral(newValue).value();
-            if(newValue === oldValue) {
-                return true
-            }
-
-        }
-        if(oldValue == newValue) {
-            return true;
-        }
-        return equal(oldValue, newValue);
-    }
-}