LWC Datatable with Bulk Delete & Export to CSV

import { LightningElement, wire,track } from 'lwc';
import getRecords from '@salesforce/apex/BulkDeleteController.getRecords';
import getRecordsForLstIds from '@salesforce/apex/BulkDeleteController.getRecordsForLstIds';
import deleteLstRecords from '@salesforce/apex/BulkDeleteController.deleteLstRecords';
import { refreshApex } from '@salesforce/apex';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';
import { NavigationMixin } from 'lightning/navigation';

export default class DatatableBulkDelete extends NavigationMixin(LightningElement)  {
    
    objectName = 'Account';
    lstRecords;
    selectRecordLst = [];
    updatedselectRecordLst = [];
    recordsLst = [];
    selectedRows = [];
    isModelOpen = false;
    isLoaded = false;
    recordToDelete = false;
    deleteButtonReadOnly = true;
    orgUrl;
    isRemoveClicked  = false;
    isAcs = false;
    defaultSortDirection = 'asc';
    @track sortDirection = 'asc';
    sortedBy = 'Name';
    @track record = [];


    @track recordsCount = 0;
    columns = [
        { label: 'Id', fieldName: 'Id', type: 'text' },
        { label: 'Name', fieldName: 'Name', type: 'text',sortable: true },
        { label: 'Account Number', fieldName: 'AccountNumber', type: 'picklist' },
        { label: 'Rating', fieldName: 'Rating', type: 'text' },
        { label: 'Created Date', fieldName: 'CreatedDate', type: 'date' , typeAttributes:{day:'numeric',month:'short',year:'numeric', hour:'2-digit',minute:'2-digit',hour12:true}},
        
    ];

    headers ={
        Id:"Id",
        Name:"Name",
        AccountNumber:"Account Number",
        Rating:"Rating",
        CreatedDate:"Created Date",

    }

    connectedCallback() { 
        this.orgUrl = window.location.origin;
    }

    @wire(getRecords, { objectName: 'Account' })
    getRecords(result) {
        this.wiredRecords = result;
        if (result.data) {
            if(result.data.length){
                this.lstRecords = result.data;
            } else{
                console.error('Error fetching records', result);
            } 
        } else if (result.error) {
            console.error('Error fetching records', result.error);
        }
    }

    handleRecordSelection(event){
        const selectedRows = event.detail.selectedRows;
        let selectedRecords = [];
        this.recordsCount = event.detail.selectedRows.length;
        this.selectedRows = selectedRows
        for(const row of selectedRows){
           selectedRecords.push( row.Id);
        }
        if(selectedRecords.length) { 
            this.deleteButtonReadOnly = false;
            this.selectRecordLst = selectedRecords.join(','); 
        } else { 
            this.deleteButtonReadOnly = true;
        }
    }

    getRecordsForLstIds() { 
        let lstRecordIds = this.selectRecordLst.split(','); 
        getRecordsForLstIds({ recordIds: lstRecordIds, objectName: this.objectName })
            .then(result => {
                if (result) {
                    this.recordToDelete = true;
                    result.forEach(item => {
                    let keys = Object.keys(item);
                    let nameKey = keys.find(key => key !== 'Id');
                    if (nameKey) {
                        this.recordsLst.push({Id: item['Id'],Name: item[nameKey], recordLink: this.orgUrl + '/' + item['Id']
                    });
                    this.isLoaded = true;
                }
            });}
        })
        .catch(error => {
            console.log('Error in getting ids ', error);
        });
    } 

    openModel() { 
        this.isModelOpen = true;
        this.getRecordsForLstIds();
    } 
    
    closeModel() { 
        this.recordsLst = [];
        this.isModelOpen = false;
        this.recordToDelete = false;
        this.isLoaded = false;
    }

    deleteRecords() { 
        let lstRecordIds = this.selectRecordLst.split(','); 
        if(this.updatedselectRecordLst.length ) { 
            lstRecordIds = this.updatedselectRecordLst
        } else if(this.isRemoveClicked && this.updatedselectRecordLst.length == 0) { 
            this.showtoast('No record selected');
            return;
        }
        
        deleteLstRecords({ recordIds: lstRecordIds, objectName: this.objectName })
        .then(result => {
            if(result == 'success') { 
                this.showtoast(this.recordsCount + ' records deleted successfully.', 'success');
                this.selectRecordLst = [];
                this.recordsLst = [];
                this.refreshData();
                this.deleteButtonReadOnly = true;
                this.isModelOpen = false;
                this.recordToDelete = false;
            } else { 
                this.deleteButtonReadOnly = true;
                this.showtoast('error in deleting records : ' + result, 'error');
            }
            this.template.querySelector('lightning-datatable').selectedRows = [];

            this.recordsCount = 0;
        })
        .catch(error => {
            this.isModelOpen = false;
            this.deleteButtonReadOnly = true;
            console.log('An error occurred while deleting. ', error)
        });
    }

    refreshData() {
        refreshApex(this.wiredRecords);
    }

    showtoast(message, variant) {
        this.dispatchEvent(
            new ShowToastEvent({
                title: message,
                variant: variant
            })
        );
    }
    removeItem(event){
        const recordId = event.target.dataset.recordId;
        let updatedRecordList = this.recordsLst.filter(function(item) {
                return item.Id != recordId;
        });
        this.recordsLst = updatedRecordList;
        this.lstRecordIds = updatedRecordList;
        this.updatedselectRecordLst = [];
        for(let i =0 ; i< this.lstRecordIds.length; i++){
            this.updatedselectRecordLst.push(this.lstRecordIds[i].Id); 
    
        }
        this.isRemoveClicked = true;
    
    }

    downloadRecords(){
        this.exportCSVFile(this.headers, this.selectedRows, "Record Sheet")
    }

    exportCSVFile(headers, totalData, fileTitle){
        if(!totalData || !totalData.length){
            return null
        }
        const jsonObject = JSON.stringify(totalData)
        const result = this.convertToCSV(jsonObject, headers)
        if(result === null) return
        const blob = new Blob([result])
        const exportedFilename = fileTitle ? fileTitle+'.csv' :'export.csv'
        if(navigator.msSaveBlob){
            navigator.msSaveBlob(blob, exportedFilename)
        } else if (navigator.userAgent.match(/iPhone|iPad|iPod/i)){
            const link = window.document.createElement('a')
            link.href='data:text/csv;charset=utf-8,' + encodeURI(result);
            link.target="_blank"
            link.download=exportedFilename
            link.click()
        } else {
            const link = document.createElement("a")
            if(link.download !== undefined){
                const url = URL.createObjectURL(blob)
                link.setAttribute("href", url)
                link.setAttribute("download", exportedFilename)
                link.style.visibility='hidden'
                document.body.appendChild(link)
                link.click()
                document.body.removeChild(link)
            }
        }
        
  
    }
    convertToCSV(objArray, headers){
        const columnDelimiter = ','
        const lineDelimiter = '\r\n'
        const actualHeaderKey = Object.keys(headers)
        const headerToShow = Object.values(headers) 
        let str = ''
        str+=headerToShow.join(columnDelimiter) 
        str+=lineDelimiter
        const data = typeof objArray !=='object' ? JSON.parse(objArray):objArray
  
        data.forEach(obj=>{
            let line = ''
            actualHeaderKey.forEach(key=>{
                if(line !=''){
                    line+=columnDelimiter
                }
                let strItem = obj[key]+''
                line+=strItem? strItem.replace(/,/g, ''):strItem
            })
            str+=line+lineDelimiter
        })
        return str
    }

    handleSortAccountData(event) {
        this.sortBy = event.detail.fieldName;
        this.sortDirection = event.detail.sortDirection;
        this.sortAccountData(event.detail.fieldName, event.detail.sortDirection);

    }
    sortAccountData(fieldname, sortDirection) {

        let parseData = JSON.parse(JSON.stringify(this.lstRecords));
        
        let keyValue = (a) => {
        
        return a[fieldname];
        
        };
        let isReverse = sortDirection === 'asc' ? 1: -1;

        parseData.sort((x, y) => {

        x = keyValue(x) ? keyValue(x) : '';

        y = keyValue(y) ? keyValue(y) : '';
        if(x > y){
            return sortDirection === 'asc' ? -1 : 1;}
        else if(y > x){
            return sortDirection === 'asc' ? 1 : -1;}
            else return 0;
        });
        this.lstRecords = parseData;
    }
    rowActionHandler(event) {
        const actionName = event.detail.action.name;
        const row = event.detail.row;
        switch ( actionName ) {
            case 'view':
                this[NavigationMixin.Navigate]({
                    type: 'standard__recordPage',
                    attributes: {
                        recordId: row.Id,
                        objectApiName: 'Account',
                        actionName: 'view'
                    }
                });
                break;
            case 'edit':
                this.refreshData();
                this[NavigationMixin.Navigate]({
                    type: 'standard__recordPage',
                    attributes: {
                        recordId: row.Id,
                        objectApiName: 'Account',
                        actionName: 'edit'
                    }
                });
                break;
            default:
        }
    }

}