@aggdirect/coolmap-services 1.3.9 → 1.4.1

package/coolmap-services/esm2022/lib/service/coolmap.service.mjs

@@ -0,0 +1,629 @@
+import { Injectable, Inject } from '@angular/core';
+import * as mapboxgl from 'mapbox-gl';
+import * as turf from '@turf/turf';
+import { BehaviorSubject } from 'rxjs';
+import { MapboxLayer } from '@deck.gl/mapbox';
+import { ArcLayer } from '@deck.gl/layers';
+import * as i0 from "@angular/core";
+import * as i1 from "./utils.service";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "./data-model";
+export class CoolmapService {
+    utils;
+    eventManager;
+    config;
+    map;
+    markerOriginList = [];
+    markerDestinationList = [];
+    initiatecoolmap = new BehaviorSubject(true);
+    reintiatecoolmap = this.initiatecoolmap.asObservable();
+    bounds = new mapboxgl.LngLatBounds();
+    originDestinationCordinates = [];
+    padding;
+    windowActualHeightWidth;
+    popup;
+    customTopForCustomer;
+    constructor(utils, eventManager, config) {
+        this.utils = utils;
+        this.eventManager = eventManager;
+        this.config = config;
+        this.customTopForCustomer = this.config.repository === 'customer' ? 65 : 0;
+        this.windowActualHeightWidth = { availHeight: 0 };
+        window.addEventListener('resize', this.onResize.bind(this));
+    }
+    initiateMapForAddRoute(el) {
+        return new Promise((resolve, reject) => {
+            if (this.map)
+                this.map.remove();
+            this.map = new mapboxgl.Map({
+                accessToken: this.config.mapboxAccessToken,
+                container: el,
+                style: this.config.mapboxStyle,
+                center: [-77.036873, 38.907192],
+                zoom: 10,
+                bearing: 0,
+                pitch: 65,
+                interactive: true,
+            });
+            this.map.once('load', (res) => {
+                resolve(res);
+            });
+        });
+    }
+    //  Below method Load route with animation
+    loadMapProperty(pinRouteGeojson, index, unit, route, bottom) {
+        return new Promise((resolve, reject) => {
+            let origin = pinRouteGeojson.features[0].geometry.coordinates[0];
+            const linecolor = unit === 'Ton' ? '#ff7272' : unit === 'Load' ? '#a3c52e' : '#ae23d1';
+            let destination = pinRouteGeojson.features[0].geometry.coordinates[pinRouteGeojson.features[0].geometry.coordinates.length - 1];
+            this.extendBound(pinRouteGeojson.features[0].geometry.coordinates, true).then((res) => {
+                const point = {
+                    type: 'FeatureCollection',
+                    features: [
+                        {
+                            type: 'Feature',
+                            properties: {},
+                            geometry: { type: 'Point', coordinates: origin },
+                        },
+                    ],
+                };
+                const lineDistance = turf.length(pinRouteGeojson.features[0]);
+                const arc = [];
+                const steps = 10 * pinRouteGeojson.features[0].geometry.coordinates.length;
+                for (let i = 0; i < lineDistance; i += lineDistance / steps) {
+                    const segment = turf.along(pinRouteGeojson.features[0], i);
+                    arc.push(segment.geometry.coordinates);
+                }
+                pinRouteGeojson.features[0].geometry.coordinates = arc;
+                const pinRoute = pinRouteGeojson.features[0].geometry.coordinates;
+                const marker = new mapboxgl.Marker(document.createElement('div'))
+                    .setLngLat(pinRoute[0])
+                    .addTo(this.map)
+                    .togglePopup();
+                if (this.map.getSource(`line${index}`)) {
+                    this.removeRouteAndMarker(index).then(() => { });
+                }
+                this.map.addSource(`line${index}`, {
+                    type: 'geojson',
+                    lineMetrics: true,
+                    data: pinRouteGeojson,
+                });
+                this.map.addLayer({
+                    type: 'line',
+                    source: `line${index}`,
+                    id: `line${index}`,
+                    paint: {
+                        'line-width': 2,
+                        'line-gradient': [
+                            'interpolate',
+                            ['linear'],
+                            ['line-progress'],
+                            0,
+                            unit === 'Ton'
+                                ? '#d7f7e4'
+                                : unit === 'Load'
+                                    ? '#c9d8f5'
+                                    : '#f5dcc1',
+                            1,
+                            unit === 'Ton'
+                                ? '#ff7272'
+                                : unit === 'Load'
+                                    ? '#a3c52e'
+                                    : '#ae23d1',
+                        ],
+                    },
+                    layout: { 'line-cap': 'round', 'line-join': 'round' },
+                });
+                const dataSetForMap = {
+                    counter: 0,
+                    pinRouteGeojson,
+                    steps,
+                    point,
+                    pointId: `point${index}`,
+                    marker,
+                    pinRoute,
+                    lineId: `line${index}`,
+                    index,
+                    origin,
+                    destination,
+                    lineDistance,
+                    linecolor,
+                    route,
+                    isViewRoute: true,
+                };
+                this.createMarker(dataSetForMap);
+                this.map.on('mouseenter', `line${index}`, (e) => {
+                    this.map.setPaintProperty(`line${index}`, 'line-width', 5);
+                    this.map.setPaintProperty(`line${index}`, 'line-opacity', 1);
+                    const datasetForPopup = {
+                        coordinate: [e.lngLat.lng, e.lngLat.lat],
+                        pickup: route.pickup_location ? route.pickup_location : '',
+                        drop: route.delivery_location ? route.delivery_location : '',
+                        routeType: route.project ? 'Project' : 'Route',
+                        title: route.project
+                            ? route.project
+                            : route.route_name
+                                ? route.route_name
+                                : '',
+                        material: route.material ? route.material : '',
+                        type: route.unit ? route.unit : '',
+                    };
+                    this.createPopup(datasetForPopup);
+                });
+                this.map.on('mouseleave', `line${index}`, (e) => {
+                    this.map.setPaintProperty(`line${index}`, 'line-width', 2);
+                    if (this.popup) {
+                        this.popup.remove();
+                    }
+                });
+            });
+            this.map.once('idle', (res) => {
+                resolve(true);
+            });
+        });
+    }
+    //  Below method Load route without animation
+    drawLine(cordinates, index, route, enablefitbound, routeType) {
+        let linecolor;
+        let origin = cordinates[0];
+        let destination = cordinates[cordinates.length - 1];
+        if (origin[0] &&
+            origin[1] &&
+            destination &&
+            destination[0] &&
+            destination[1]) {
+            linecolor = this.provideLineColor(route['unit'], routeType);
+            if (enablefitbound) {
+                const padding = {
+                    top: this.padding.top + this.customTopForCustomer,
+                    bottom: this.padding.bottom +
+                        (this.windowActualHeightWidth.availHeight -
+                            (window.innerHeight - 65)),
+                    left: this.padding.left,
+                    right: this.padding.right,
+                };
+                this.map.fitBounds([origin, destination], { padding, pitch: 65 }, { fitboundCompleteJob: true });
+            }
+            if (this.map.getSource(`route-source-for-job-code${index}`)) {
+                this.removeRouteAndMarker(index).then(() => { });
+            }
+            this.map.addSource(`route-source-for-job-code${index}`, {
+                type: 'geojson',
+                data: {
+                    type: 'Feature',
+                    properties: {},
+                    geometry: { type: 'LineString', coordinates: cordinates },
+                },
+            });
+            this.map.addLayer({
+                id: `route-for-job-code${index}`,
+                type: 'line',
+                source: `route-source-for-job-code${index}`,
+                paint: { 'line-color': linecolor, 'line-width': 2 },
+                layout: { 'line-cap': 'round', 'line-join': 'round' },
+            });
+            const dataSetForMap = {
+                origin,
+                destination,
+                index,
+                linecolor,
+                route,
+            };
+            this.createMarker(dataSetForMap);
+            this.map.on('mouseenter', `route-for-job-code${index}`, (e) => {
+                if (this.popup) {
+                    this.popup.remove();
+                }
+                this.map.setPaintProperty(`route-for-job-code${index}`, 'line-width', 5);
+                this.map.setPaintProperty(`route-for-job-code${index}`, 'line-opacity', 1);
+                const datasetForPopup = {
+                    coordinate: [e.lngLat.lng, e.lngLat.lat],
+                    pickup: route.pickup_location ? route.pickup_location : '',
+                    drop: route.delivery_location ? route.delivery_location : '',
+                    jobCode: route.project ? route.order_number : null,
+                    customer: route.project ? route.customer_name : null,
+                    routeType: route.project ? 'Project' : 'Route',
+                    title: route.project
+                        ? route.project
+                        : route.route_name
+                            ? route.route_name
+                            : '',
+                    material: route.material ? route.material : '',
+                    type: route.unit ? route.unit : '',
+                };
+                this.createPopup(datasetForPopup);
+            });
+            this.map.on('mouseleave', `route-for-job-code${index}`, (e) => {
+                this.map.setPaintProperty(`route-for-job-code${index}`, 'line-width', 2);
+                if (this.popup) {
+                    this.popup.remove();
+                }
+            });
+        }
+    }
+    provideLineColor(unitType, type) {
+        let checkType = type && !['jobrouteList', 'addroute'].includes(type) ? true : false;
+        let color;
+        switch (unitType) {
+            case 'Ton':
+                color = checkType ? '#39c471' : '#ff7272';
+                break;
+            case 'Load':
+                color = checkType ? '#326ad3' : '#a3c52e';
+                break;
+            case 'Hourly':
+                color = checkType ? '#ffad56' : '#ae23d1';
+                break;
+        }
+        return color;
+    }
+    showRoutePopup(arcDetails, event, isViewRoute) {
+        if (this.popup) {
+            this.popup.remove();
+            this.map.setPaintProperty(`${isViewRoute ? 'line' : 'route-for-job-code'}${arcDetails.layer.props.data.index}`, 'line-width', 2);
+        }
+        if (arcDetails.color &&
+            this.map.getLayoutProperty(arcDetails.layer.id, 'visibility') !== 'none') {
+            this.map.setPaintProperty(`${isViewRoute ? 'line' : 'route-for-job-code'}${arcDetails.layer.props.data.index}`, 'line-width', 5);
+            this.map.setPaintProperty(`${isViewRoute ? 'line' : 'route-for-job-code'}${arcDetails.layer.props.data.index}`, 'line-opacity', 1);
+            const datasetForPopup = {
+                coordinate: arcDetails.coordinate,
+                pickup: arcDetails.layer.props.data.route.pickup_location
+                    ? arcDetails.layer.props.data.route.pickup_location
+                    : '',
+                drop: arcDetails.layer.props.data.route.delivery_location
+                    ? arcDetails.layer.props.data.route.delivery_location
+                    : '',
+                jobCode: arcDetails.layer.props.data.route.project
+                    ? arcDetails.layer.props.data.route.order_number
+                    : '',
+                customer: arcDetails.layer.props.data.route.project
+                    ? arcDetails.layer.props.data.route.customer_name
+                    : '',
+                routeType: arcDetails.layer.props.data.route.project
+                    ? 'Project'
+                    : 'Route',
+                title: arcDetails.layer.props.data.route.project
+                    ? arcDetails.layer.props.data.route.project
+                    : arcDetails.layer.props.data.route.route_name
+                        ? arcDetails.layer.props.data.route.route_name
+                        : '',
+                material: arcDetails.layer.props.data.route.material
+                    ? arcDetails.layer.props.data.route.material
+                    : '',
+                type: arcDetails.layer.props.data.route.unit
+                    ? arcDetails.layer.props.data.route.unit
+                    : '',
+            };
+            this.createPopup(datasetForPopup);
+        }
+    }
+    createPopup(datasetForPopup) {
+        this.popup = new mapboxgl.Popup({
+            closeButton: false,
+            closeOnClick: false,
+            closeOnMove: true,
+            anchor: 'bottom-left',
+        });
+        this.popup
+            .setLngLat(datasetForPopup.coordinate)
+            .setHTML(`<div class="destination">
+          <div class="duration">
+            <p class="pickprt"><b>Pickup Location:</b> ${datasetForPopup.pickup}</p>
+            <p class="dropprt"><b>Drop Location:</b> ${datasetForPopup.drop}</p>
+          </div>
+          ${datasetForPopup.jobCode
+            ? '<span><b>Job Code:</b> ' + datasetForPopup.jobCode + '</span>'
+            : ''}
+          ${datasetForPopup.customer
+            ? '<span><b>Customer:</b> ' + datasetForPopup.customer + '</span>'
+            : ''}
+          <span>
+            <b>${datasetForPopup.routeType} Name:</b> 
+               ${datasetForPopup.title}
+          </span>
+          ${datasetForPopup.material
+            ? '<span><b>Material:</b> ' + datasetForPopup.material + '</span>'
+            : ''}
+          <span><b>Type:</b> ${datasetForPopup.type}</span>
+      </div>`)
+            .addTo(this.map);
+    }
+    hexToRGB(hex) {
+        return hex
+            .replace(/^#?([a-f\d])([a-f\d])([a-f\d])$/i, (m, r, g, b) => '#' + r + r + g + g + b + b)
+            .substring(1)
+            .match(/.{2}/g)
+            .map((x) => parseInt(x, 16));
+    }
+    createMarker(routeDetails) {
+        if (routeDetails.origin[0] &&
+            routeDetails.origin[1] &&
+            routeDetails.destination[0] &&
+            routeDetails.destination[1]) {
+            const popup = new mapboxgl.Popup({ closeButton: false }).setHTML('<b>Pickup: </b>' + routeDetails.route?.pickup_location);
+            const popupForDestination = new mapboxgl.Popup({
+                closeButton: false,
+            }).setHTML('<b>Delivery: </b>' + routeDetails.route?.delivery_location);
+            const el = document.createElement('div');
+            el.className = 'marker';
+            el.innerHTML = `<span class='markerPointer' style='background:${routeDetails.linecolor}'><b>P</b><span class='markerSpan' style='border-top: 10px solid ${routeDetails.linecolor}'></span></span>`;
+            const originMarker = new mapboxgl.Marker(el)
+                .setPopup(popup)
+                .setLngLat(routeDetails.origin)
+                .addTo(this.map);
+            originMarker
+                .getElement()
+                .addEventListener('mouseenter', () => originMarker.togglePopup());
+            originMarker
+                .getElement()
+                .addEventListener('mouseleave', () => originMarker.togglePopup());
+            const elementForDestination = document.createElement('div');
+            elementForDestination.className = 'marker';
+            elementForDestination.innerHTML = `<span class='markerPointer' style='background:${routeDetails.linecolor}'><b>D</b><span class='markerSpan' style='border-top: 10px solid ${routeDetails.linecolor}'></span></span>`;
+            const destinationMarker = new mapboxgl.Marker(elementForDestination)
+                .setPopup(popupForDestination)
+                .setLngLat(routeDetails.destination)
+                .addTo(this.map);
+            destinationMarker
+                .getElement()
+                .addEventListener('mouseenter', () => destinationMarker.togglePopup());
+            destinationMarker
+                .getElement()
+                .addEventListener('mouseleave', () => destinationMarker.togglePopup());
+            this.markerOriginList[routeDetails.index] = originMarker;
+            this.markerDestinationList[routeDetails.index] = destinationMarker;
+            const colorArray = this.hexToRGB(routeDetails.linecolor);
+            const arcLayer = new MapboxLayer({
+                id: 'arc-layer' + routeDetails.index,
+                type: ArcLayer,
+                pickable: true,
+                data: { route: routeDetails.route, index: routeDetails.index },
+                getWidth: 1,
+                getSourcePosition: routeDetails.origin,
+                getTargetPosition: routeDetails.destination,
+                getTargetColor: [255, 255, 255],
+                getSourceColor: [colorArray[0], colorArray[1], colorArray[2]],
+                onHover: (info, event) => this.showRoutePopup(info, event, routeDetails.isViewRoute),
+            });
+            this.map.addLayer(arcLayer);
+        }
+    }
+    async removeRouteAndMarker(index) {
+        if (this.map) {
+            this.map.getLayer(`arc-layer${index}`)
+                ? this.map.removeLayer(`arc-layer${index}`)
+                : '';
+            this.map.getLayer(`line${index}`)
+                ? this.map.removeLayer(`line${index}`)
+                : '';
+            this.map.getLayer(`custom_layer${index}`)
+                ? this.map.removeLayer(`custom_layer${index}`)
+                : '';
+            this.map.getSource(`line${index}`)
+                ? this.map.removeSource(`line${index}`)
+                : '';
+            this.map.getLayer(`route-for-job-code${index}`)
+                ? this.map.removeLayer(`route-for-job-code${index}`)
+                : '';
+            this.map.getSource(`route-source-for-job-code${index}`)
+                ? this.map.removeSource(`route-source-for-job-code${index}`)
+                : '';
+            this.findMarkerBound(index);
+            this.markerOriginList[index] ? this.markerOriginList[index].remove() : '';
+            this.markerDestinationList[index]
+                ? this.markerDestinationList[index].remove()
+                : '';
+            await true;
+        }
+    }
+    findMarkerBound(index) {
+        const indexOfCordinates = this.originDestinationCordinates.findIndex((x) => x[0][0].toFixed(6) ==
+            this.markerOriginList[index]?.getLngLat()?.lng.toFixed(6) &&
+            x[0][1].toFixed(6) ==
+                this.markerOriginList[index]?.getLngLat()?.lat.toFixed(6));
+        if (indexOfCordinates >= 0) {
+            this.originDestinationCordinates.splice(indexOfCordinates, 1);
+        }
+    }
+    async filterRoute(ID, visibility, showAllFitbound) {
+        if (ID) {
+            if (this.map.getLayer(`route-for-job-code${ID}`)) {
+                this.map.setLayoutProperty(`route-for-job-code${ID}`, 'visibility', visibility);
+                const originM = this.markerOriginList[ID].getElement();
+                originM.style.display = visibility === 'visible' ? 'block' : visibility;
+                const destinationM = this.markerDestinationList[ID].getElement();
+                destinationM.style.display =
+                    visibility === 'visible' ? 'block' : visibility;
+                if (visibility === 'none' && showAllFitbound) {
+                    this.findMarkerBound(ID);
+                    this.extendReBound();
+                }
+            }
+            if (this.map.getLayer(`arc-layer${ID}`)) {
+                this.map.setLayoutProperty(`arc-layer${ID}`, 'visibility', visibility);
+            }
+        }
+        await true;
+    }
+    extendBound(route, showAllFitbound) {
+        return new Promise((resolve, reject) => {
+            if (route) {
+                if (typeof route === 'string') {
+                    let path = route.split(';');
+                    path = path.map((ele) => {
+                        return (ele = this.formateLatLong(ele));
+                    });
+                    path.forEach((ele, index) => {
+                        if (ele.length === 1)
+                            path.splice(index, 1);
+                    });
+                    route = path;
+                }
+                if (route[0][0] &&
+                    route[0][1] &&
+                    route[route.length - 1][0] &&
+                    route[route.length - 1][1]) {
+                    this.originDestinationCordinates.push(route);
+                    route.map((item) => {
+                        this.bounds.extend(item);
+                    });
+                }
+            }
+            if (showAllFitbound) {
+                setTimeout(() => {
+                    if (showAllFitbound && Object.keys(this.bounds).length > 0)
+                        this.map.fitBounds(this.bounds, { pitch: 65 }, { fitboundComplete: true });
+                }, 100);
+                this.map.once('moveend', (event) => {
+                    if (event.fitboundComplete) {
+                        resolve(true);
+                    }
+                });
+            }
+        });
+    }
+    extendReBound(bottom) {
+        return new Promise((resolve, reject) => {
+            this.bounds = new mapboxgl.LngLatBounds();
+            if (this.originDestinationCordinates.length >= 0) {
+                this.originDestinationCordinates.map((item, index) => {
+                    item.map((route) => {
+                        this.bounds.extend(route);
+                    });
+                    if (index === this.originDestinationCordinates.length - 1) {
+                        const padding = {
+                            top: this.padding.top + this.customTopForCustomer,
+                            bottom: this.padding.bottom +
+                                (this.windowActualHeightWidth.availHeight -
+                                    (window.innerHeight - 65)),
+                            left: this.padding.left,
+                            right: this.padding.right,
+                        };
+                        setTimeout(() => {
+                            if (this.originDestinationCordinates.length > 0)
+                                this.map.fitBounds(this.bounds, { padding, pitch: 65 });
+                        }, 500);
+                        resolve(true);
+                    }
+                });
+            }
+            else {
+                resolve(true);
+            }
+        });
+    }
+    plotRoute(route, i, type, enablefitbound, showAllFitbound) {
+        return new Promise((resolve, reject) => {
+            let param = {};
+            if (['jobcode'].includes(type)) {
+                param['job'] = route['job_id'];
+                this.utils.postDataWithRestUrl('schedule/job/path', param).subscribe((res) => {
+                    if (res['data']['route']) {
+                        let path = res['data']['route'].split(';');
+                        path = path.map((ele) => {
+                            return (ele = this.formateLatLong(ele));
+                        });
+                        path.forEach((ele, index) => {
+                            if (ele.length === 1)
+                                path.splice(index, 1);
+                        });
+                        route['path'] = path;
+                        this.extendBound(route['path'], showAllFitbound);
+                        if (route['path'] && route['path'].length > 0)
+                            this.drawLine(route['path'], i, route, enablefitbound, type);
+                        route['index'] = i;
+                    }
+                    else {
+                        this.extendBound(null, showAllFitbound);
+                    }
+                    resolve(true);
+                }, (err) => {
+                    if (err) {
+                        reject(false);
+                    }
+                });
+            }
+            else if (['jobrouteList', 'addroute'].includes(type)) {
+                if (route['path'] && route['path'].length > 0) {
+                    let path = route['path'].split(';');
+                    path = path.map((ele) => {
+                        return (ele = this.formateLatLong(ele));
+                    });
+                    path.forEach((ele, index) => {
+                        if (ele.length === 1)
+                            path.splice(index, 1);
+                    });
+                    this.extendBound(path, showAllFitbound);
+                    this.drawLine(path, i, route, enablefitbound, type);
+                }
+            }
+        });
+    }
+    clearBound() {
+        this.bounds = new mapboxgl.LngLatBounds();
+        this.originDestinationCordinates = [];
+        this.clearPadding();
+    }
+    formateLatLong(latlong) {
+        return latlong
+            ? latlong
+                .split(',')
+                .map((x) => +x)
+                .reverse()
+            : null;
+    }
+    clearBoundWithCordinates() {
+        this.bounds = new mapboxgl.LngLatBounds();
+        this.originDestinationCordinates = [];
+    }
+    onResize(event) {
+        if (!this.bounds.isEmpty()) {
+            this.windowActualHeightWidth.availHeight =
+                window.innerHeight > window.screen.availHeight
+                    ? window.innerHeight
+                    : window.screen.availHeight;
+            setTimeout(() => {
+                this.map.fitBounds(this.bounds, {
+                    padding: {
+                        top: this.padding.top + this.customTopForCustomer,
+                        bottom: this.padding.bottom +
+                            (this.windowActualHeightWidth.availHeight -
+                                (event.target.innerHeight - 65)),
+                        left: this.padding.left,
+                        right: this.padding.right,
+                    },
+                    pitch: 65,
+                });
+            }, 500);
+        }
+    }
+    setWindowHeight(screen) {
+        this.windowActualHeightWidth.availHeight = screen;
+    }
+    setPadding(padding) {
+        this.padding = padding;
+    }
+    clearPadding() {
+        this.padding = null;
+    }
+    removeJobFromMap(data) {
+        data.map((ele, index) => {
+            const id = ele['job_id'] ? ele['job_id'] : ele['route_id'];
+            this.removeRouteAndMarker(id);
+            if (index === data.length - 1) {
+                this.extendReBound();
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: CoolmapService, deps: [{ token: i1.UtilsService }, { token: i2.EventManager }, { token: 'memberData' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: CoolmapService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: CoolmapService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.UtilsService }, { type: i2.EventManager }, { type: i3.CoolmapConfigModel, decorators: [{
+                    type: Inject,
+                    args: ['memberData']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coolmap.service.js","sourceRoot":"","sources":["../../../../../../projects/coolmap-services/src/lib/service/coolmap.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport * as mapboxgl from 'mapbox-gl';\nimport * as turf from '@turf/turf';\nimport { BehaviorSubject } from 'rxjs';\nimport { CoolmapConfigModel, PopupData, Route } from './data-model';\nimport { UtilsService } from './utils.service';\nimport { EventManager } from '@angular/platform-browser';\nimport { MapboxLayer } from '@deck.gl/mapbox';\nimport { ArcLayer } from '@deck.gl/layers';\n\ndeclare const Threebox: any;\n\n@Injectable({ providedIn: 'root' })\nexport class CoolmapService {\n  map!: mapboxgl.Map;\n  markerOriginList: mapboxgl.Marker[] = [];\n  markerDestinationList: mapboxgl.Marker[] = [];\n  initiatecoolmap = new BehaviorSubject(true);\n  reintiatecoolmap = this.initiatecoolmap.asObservable();\n  bounds = new mapboxgl.LngLatBounds();\n  originDestinationCordinates: any = [];\n  padding!: any;\n  windowActualHeightWidth!: any;\n  popup: mapboxgl.Popup;\n  customTopForCustomer: number;\n\n  constructor(\n    public utils: UtilsService,\n    public eventManager: EventManager,\n    @Inject('memberData') private config: CoolmapConfigModel\n  ) {\n    this.customTopForCustomer = this.config.repository === 'customer' ? 65 : 0;\n    this.windowActualHeightWidth = { availHeight: 0 };\n    window.addEventListener('resize', this.onResize.bind(this));\n  }\n\n  initiateMapForAddRoute(el: HTMLElement) {\n    return new Promise((resolve, reject) => {\n      if (this.map) this.map.remove();\n      this.map = new mapboxgl.Map({\n        accessToken: this.config.mapboxAccessToken,\n        container: el,\n        style: this.config.mapboxStyle,\n        center: [-77.036873, 38.907192],\n        zoom: 10,\n        bearing: 0,\n        pitch: 65,\n        interactive: true,\n      });\n      this.map.once('load', (res) => {\n        resolve(res);\n      });\n    });\n  }\n  //  Below method Load route with animation\n  loadMapProperty(\n    pinRouteGeojson: any,\n    index: number,\n    unit: any,\n    route?: any,\n    bottom?: number\n  ) {\n    return new Promise((resolve, reject) => {\n      let origin = pinRouteGeojson.features[0].geometry.coordinates[0];\n      const linecolor =\n        unit === 'Ton' ? '#ff7272' : unit === 'Load' ? '#a3c52e' : '#ae23d1';\n      let destination =\n        pinRouteGeojson.features[0].geometry.coordinates[\n          pinRouteGeojson.features[0].geometry.coordinates.length - 1\n        ];\n      this.extendBound(\n        pinRouteGeojson.features[0].geometry.coordinates,\n        true\n      ).then((res: any) => {\n        const point: any = {\n          type: 'FeatureCollection',\n          features: [\n            {\n              type: 'Feature',\n              properties: {},\n              geometry: { type: 'Point', coordinates: origin },\n            },\n          ],\n        };\n        const lineDistance = turf.length(pinRouteGeojson.features[0]);\n        const arc = [];\n        const steps =\n          10 * pinRouteGeojson.features[0].geometry.coordinates.length;\n        for (let i = 0; i < lineDistance; i += lineDistance / steps) {\n          const segment = turf.along(pinRouteGeojson.features[0], i);\n          arc.push(segment.geometry.coordinates);\n        }\n        pinRouteGeojson.features[0].geometry.coordinates = arc;\n        const pinRoute = pinRouteGeojson.features[0].geometry.coordinates;\n        const marker = new mapboxgl.Marker(document.createElement('div'))\n          .setLngLat(pinRoute[0])\n          .addTo(this.map)\n          .togglePopup();\n\n        if (this.map.getSource(`line${index}`)) {\n          this.removeRouteAndMarker(index).then(() => {});\n        }\n\n        this.map.addSource(`line${index}`, {\n          type: 'geojson',\n          lineMetrics: true,\n          data: pinRouteGeojson,\n        });\n        this.map.addLayer({\n          type: 'line',\n          source: `line${index}`,\n          id: `line${index}`,\n          paint: {\n            'line-width': 2,\n            'line-gradient': [\n              'interpolate',\n              ['linear'],\n              ['line-progress'],\n              0,\n              unit === 'Ton'\n                ? '#d7f7e4'\n                : unit === 'Load'\n                ? '#c9d8f5'\n                : '#f5dcc1',\n              1,\n              unit === 'Ton'\n                ? '#ff7272'\n                : unit === 'Load'\n                ? '#a3c52e'\n                : '#ae23d1',\n            ],\n          },\n          layout: { 'line-cap': 'round', 'line-join': 'round' },\n        });\n\n        const dataSetForMap = {\n          counter: 0,\n          pinRouteGeojson,\n          steps,\n          point,\n          pointId: `point${index}`,\n          marker,\n          pinRoute,\n          lineId: `line${index}`,\n          index,\n          origin,\n          destination,\n          lineDistance,\n          linecolor,\n          route,\n          isViewRoute: true,\n        };\n        this.createMarker(dataSetForMap);\n        this.map.on('mouseenter', `line${index}`, (e) => {\n          this.map.setPaintProperty(`line${index}`, 'line-width', 5);\n          this.map.setPaintProperty(`line${index}`, 'line-opacity', 1);\n          const datasetForPopup: PopupData = {\n            coordinate: [e.lngLat.lng, e.lngLat.lat],\n            pickup: route.pickup_location ? route.pickup_location : '',\n            drop: route.delivery_location ? route.delivery_location : '',\n            routeType: route.project ? 'Project' : 'Route',\n            title: route.project\n              ? route.project\n              : route.route_name\n              ? route.route_name\n              : '',\n            material: route.material ? route.material : '',\n            type: route.unit ? route.unit : '',\n          };          \n          this.createPopup(datasetForPopup);\n        });\n        this.map.on('mouseleave', `line${index}`, (e) => {\n          this.map.setPaintProperty(`line${index}`, 'line-width', 2);\n          if (this.popup) {\n            this.popup.remove();\n          }\n        });\n      });\n\n      this.map.once('idle', (res) => {\n        resolve(true);\n      });\n    });\n  }\n  //  Below method Load route without animation\n  drawLine(\n    cordinates?: any,\n    index?: number | any,\n    route?: any,\n    enablefitbound?: boolean,\n    routeType?: string\n  ) {    \n    let linecolor: any;\n    let origin = cordinates[0];\n    let destination = cordinates[cordinates.length - 1];\n    if (\n      origin[0] &&\n      origin[1] &&\n      destination &&\n      destination[0] &&\n      destination[1]\n    ) {\n      linecolor = this.provideLineColor(route['unit'], routeType);\n      if (enablefitbound) {\n        const padding = {\n          top: this.padding.top + this.customTopForCustomer,\n          bottom:\n            this.padding.bottom +\n            (this.windowActualHeightWidth.availHeight -\n              (window.innerHeight - 65)),\n          left: this.padding.left,\n          right: this.padding.right,\n        };\n        this.map.fitBounds(\n          [origin, destination],\n          { padding, pitch: 65 },\n          { fitboundCompleteJob: true }\n        );\n      }\n      if (this.map.getSource(`route-source-for-job-code${index}`)) {\n        this.removeRouteAndMarker(index).then(() => {});\n      }\n      this.map.addSource(`route-source-for-job-code${index}`, {\n        type: 'geojson',\n        data: {\n          type: 'Feature',\n          properties: {},\n          geometry: { type: 'LineString', coordinates: cordinates },\n        },\n      });\n      this.map.addLayer({\n        id: `route-for-job-code${index}`,\n        type: 'line',\n        source: `route-source-for-job-code${index}`,\n        paint: { 'line-color': linecolor, 'line-width': 2 },\n        layout: { 'line-cap': 'round', 'line-join': 'round' },\n      });\n      const dataSetForMap = {\n        origin,\n        destination,\n        index,\n        linecolor,\n        route,\n      };\n      this.createMarker(dataSetForMap);\n      this.map.on('mouseenter', `route-for-job-code${index}`, (e) => {\n        if (this.popup) {\n          this.popup.remove();\n        }\n        this.map.setPaintProperty(\n          `route-for-job-code${index}`,\n          'line-width',\n          5\n        );\n        this.map.setPaintProperty(\n          `route-for-job-code${index}`,\n          'line-opacity',\n          1\n        );\n        const datasetForPopup: PopupData = {\n          coordinate: [e.lngLat.lng, e.lngLat.lat],\n          pickup: route.pickup_location ? route.pickup_location : '',\n          drop: route.delivery_location ? route.delivery_location : '',\n          jobCode: route.project ? route.order_number : null,\n          customer: route.project ? route.customer_name : null,\n          routeType: route.project ? 'Project' : 'Route',\n          title: route.project\n            ? route.project\n            : route.route_name\n            ? route.route_name\n            : '',\n          material: route.material ? route.material : '',\n          type: route.unit ? route.unit : '',\n        };        \n        this.createPopup(datasetForPopup);\n      });\n      this.map.on('mouseleave', `route-for-job-code${index}`, (e) => {\n        this.map.setPaintProperty(\n          `route-for-job-code${index}`,\n          'line-width',\n          2\n        );\n        if (this.popup) {\n          this.popup.remove();\n        }\n      });\n    }\n  }\n\n  provideLineColor(unitType: string, type?: string | undefined) {\n    let checkType =\n      type && !['jobrouteList', 'addroute'].includes(type) ? true : false;\n    let color;\n    switch (unitType) {\n      case 'Ton':\n        color = checkType ? '#39c471' : '#ff7272';\n        break;\n      case 'Load':\n        color = checkType ? '#326ad3' : '#a3c52e';\n        break;\n      case 'Hourly':\n        color = checkType ? '#ffad56' : '#ae23d1';\n        break;\n    }\n    return color;\n  }\n\n  showRoutePopup(arcDetails, event, isViewRoute?): void {\n    if (this.popup) {\n      this.popup.remove();\n      this.map.setPaintProperty(\n        `${isViewRoute ? 'line' : 'route-for-job-code'}${\n          arcDetails.layer.props.data.index\n        }`,\n        'line-width',\n        2\n      );\n    }\n    if (\n      arcDetails.color &&\n      this.map.getLayoutProperty(arcDetails.layer.id, 'visibility') !== 'none'\n    ) {\n      this.map.setPaintProperty(\n        `${isViewRoute ? 'line' : 'route-for-job-code'}${\n          arcDetails.layer.props.data.index\n        }`,\n        'line-width',\n        5\n      );\n      this.map.setPaintProperty(\n        `${isViewRoute ? 'line' : 'route-for-job-code'}${\n          arcDetails.layer.props.data.index\n        }`,\n        'line-opacity',\n        1\n      );\n\n      const datasetForPopup: PopupData = {\n        coordinate: arcDetails.coordinate,\n        pickup: arcDetails.layer.props.data.route.pickup_location\n          ? arcDetails.layer.props.data.route.pickup_location\n          : '',\n        drop: arcDetails.layer.props.data.route.delivery_location\n          ? arcDetails.layer.props.data.route.delivery_location\n          : '',\n        jobCode: arcDetails.layer.props.data.route.project\n          ? arcDetails.layer.props.data.route.order_number\n          : '',\n        customer: arcDetails.layer.props.data.route.project\n          ? arcDetails.layer.props.data.route.customer_name\n          : '',\n        routeType: arcDetails.layer.props.data.route.project\n          ? 'Project'\n          : 'Route',\n        title: arcDetails.layer.props.data.route.project\n          ? arcDetails.layer.props.data.route.project\n          : arcDetails.layer.props.data.route.route_name\n          ? arcDetails.layer.props.data.route.route_name\n          : '',\n        material: arcDetails.layer.props.data.route.material\n          ? arcDetails.layer.props.data.route.material\n          : '',\n        type: arcDetails.layer.props.data.route.unit\n          ? arcDetails.layer.props.data.route.unit\n          : '',\n      };      \n      this.createPopup(datasetForPopup);\n    }\n  }\n\n  createPopup(datasetForPopup: PopupData): void {\n    this.popup = new mapboxgl.Popup({\n      closeButton: false,\n      closeOnClick: false,\n      closeOnMove: true,\n      anchor: 'bottom-left',\n    });\n\n    this.popup\n      .setLngLat(datasetForPopup.coordinate)\n      .setHTML(\n      `<div class=\"destination\">\n          <div class=\"duration\">\n            <p class=\"pickprt\"><b>Pickup Location:</b> ${\n              datasetForPopup.pickup\n            }</p>\n            <p class=\"dropprt\"><b>Drop Location:</b> ${datasetForPopup.drop}</p>\n          </div>\n          ${\n            datasetForPopup.jobCode\n              ? '<span><b>Job Code:</b> ' + datasetForPopup.jobCode + '</span>'\n              : ''\n          }\n          ${\n            datasetForPopup.customer\n              ? '<span><b>Customer:</b> ' + datasetForPopup.customer + '</span>'\n              : ''\n          }\n          <span>\n            <b>${datasetForPopup.routeType} Name:</b> \n               ${datasetForPopup.title}\n          </span>\n          ${\n            datasetForPopup.material\n              ? '<span><b>Material:</b> ' + datasetForPopup.material + '</span>'\n              : ''\n          }\n          <span><b>Type:</b> ${datasetForPopup.type}</span>\n      </div>`\n      )\n      .addTo(this.map);\n  }\n\n  hexToRGB(hex: any): [number, number, number] {\n    return hex\n      .replace(\n        /^#?([a-f\\d])([a-f\\d])([a-f\\d])$/i,\n        (m, r, g, b) => '#' + r + r + g + g + b + b\n      )\n      .substring(1)\n      .match(/.{2}/g)\n      .map((x) => parseInt(x, 16));\n  }\n\n  createMarker(routeDetails) {\n    if (\n      routeDetails.origin[0] &&\n      routeDetails.origin[1] &&\n      routeDetails.destination[0] &&\n      routeDetails.destination[1]\n    ) {\n      const popup = new mapboxgl.Popup({ closeButton: false }).setHTML(\n        '<b>Pickup: </b>' + routeDetails.route?.pickup_location\n      );\n      const popupForDestination = new mapboxgl.Popup({\n        closeButton: false,\n      }).setHTML('<b>Delivery: </b>' + routeDetails.route?.delivery_location);\n\n      const el = document.createElement('div');\n      el.className = 'marker';\n      el.innerHTML = `<span class='markerPointer' style='background:${routeDetails.linecolor}'><b>P</b><span class='markerSpan' style='border-top: 10px solid ${routeDetails.linecolor}'></span></span>`;\n\n      const originMarker = new mapboxgl.Marker(el)\n        .setPopup(popup)\n        .setLngLat(routeDetails.origin)\n        .addTo(this.map);\n\n      originMarker\n        .getElement()\n        .addEventListener('mouseenter', () => originMarker.togglePopup());\n      originMarker\n        .getElement()\n        .addEventListener('mouseleave', () => originMarker.togglePopup());\n\n      const elementForDestination = document.createElement('div');\n      elementForDestination.className = 'marker';\n      elementForDestination.innerHTML = `<span class='markerPointer' style='background:${routeDetails.linecolor}'><b>D</b><span class='markerSpan' style='border-top: 10px solid ${routeDetails.linecolor}'></span></span>`;\n\n      const destinationMarker = new mapboxgl.Marker(elementForDestination)\n        .setPopup(popupForDestination)\n        .setLngLat(routeDetails.destination)\n        .addTo(this.map);\n      destinationMarker\n        .getElement()\n        .addEventListener('mouseenter', () => destinationMarker.togglePopup());\n      destinationMarker\n        .getElement()\n        .addEventListener('mouseleave', () => destinationMarker.togglePopup());\n      this.markerOriginList[routeDetails.index] = originMarker;\n      this.markerDestinationList[routeDetails.index] = destinationMarker;\n\n      const colorArray = this.hexToRGB(routeDetails.linecolor);\n      const arcLayer = new MapboxLayer({\n        id: 'arc-layer' + routeDetails.index,\n        type: ArcLayer,\n        pickable: true,\n        data: { route: routeDetails.route, index: routeDetails.index },\n        getWidth: 1,\n        getSourcePosition: routeDetails.origin,\n        getTargetPosition: routeDetails.destination,\n        getTargetColor: [255, 255, 255],\n        getSourceColor: [colorArray[0], colorArray[1], colorArray[2]],\n        onHover: (info, event) =>\n          this.showRoutePopup(info, event, routeDetails.isViewRoute),\n      });\n      this.map.addLayer(arcLayer);\n    }\n  }\n\n  async removeRouteAndMarker(index: number | string | any) {\n    if (this.map) {\n      this.map.getLayer(`arc-layer${index}`)\n        ? this.map.removeLayer(`arc-layer${index}`)\n        : '';\n      this.map.getLayer(`line${index}`)\n        ? this.map.removeLayer(`line${index}`)\n        : '';\n      this.map.getLayer(`custom_layer${index}`)\n        ? this.map.removeLayer(`custom_layer${index}`)\n        : '';\n      this.map.getSource(`line${index}`)\n        ? this.map.removeSource(`line${index}`)\n        : '';\n      this.map.getLayer(`route-for-job-code${index}`)\n        ? this.map.removeLayer(`route-for-job-code${index}`)\n        : '';\n      this.map.getSource(`route-source-for-job-code${index}`)\n        ? this.map.removeSource(`route-source-for-job-code${index}`)\n        : '';\n      this.findMarkerBound(index);\n      this.markerOriginList[index] ? this.markerOriginList[index].remove() : '';\n      this.markerDestinationList[index]\n        ? this.markerDestinationList[index].remove()\n        : '';\n      await true;\n    }\n  }\n  findMarkerBound(index: any) {\n    const indexOfCordinates = this.originDestinationCordinates.findIndex(\n      (x: any) =>\n        x[0][0].toFixed(6) ==\n          this.markerOriginList[index]?.getLngLat()?.lng.toFixed(6) &&\n        x[0][1].toFixed(6) ==\n          this.markerOriginList[index]?.getLngLat()?.lat.toFixed(6)\n    );\n    if (indexOfCordinates >= 0) {\n      this.originDestinationCordinates.splice(indexOfCordinates, 1);\n    }\n  }\n  async filterRoute(ID: any, visibility: string, showAllFitbound?: boolean) {\n    if (ID) {\n      if (this.map.getLayer(`route-for-job-code${ID}`)) {\n        this.map.setLayoutProperty(\n          `route-for-job-code${ID}`,\n          'visibility',\n          visibility\n        );\n        const originM = this.markerOriginList[ID].getElement();\n        originM.style.display = visibility === 'visible' ? 'block' : visibility;\n        const destinationM = this.markerDestinationList[ID].getElement();\n        destinationM.style.display =\n          visibility === 'visible' ? 'block' : visibility;\n        if (visibility === 'none' && showAllFitbound) {\n          this.findMarkerBound(ID);\n          this.extendReBound();\n        }\n      }\n      if (this.map.getLayer(`arc-layer${ID}`)) {\n        this.map.setLayoutProperty(`arc-layer${ID}`, 'visibility', visibility);\n      }\n    }\n    await true;\n  }\n  extendBound(route: any, showAllFitbound: boolean | undefined) {\n    return new Promise((resolve, reject) => {\n      if (route) {\n        if (typeof route === 'string') {\n          let path: any = route.split(';');\n          path = path.map((ele: string | any) => {\n            return (ele = this.formateLatLong(ele));\n          });\n          path.forEach((ele: any, index: number) => {\n            if (ele.length === 1) path.splice(index, 1);\n          });\n          route = path;\n        }\n        if (\n          route[0][0] &&\n          route[0][1] &&\n          route[route.length - 1][0] &&\n          route[route.length - 1][1]\n        ) {\n          this.originDestinationCordinates.push(route);\n          route.map((item: any) => {\n            this.bounds.extend(item);\n          });\n        }\n      }\n      if (showAllFitbound) {\n        setTimeout(() => {\n          if (showAllFitbound && Object.keys(this.bounds).length > 0)\n            this.map.fitBounds(\n              this.bounds,\n              { pitch: 65 },\n              { fitboundComplete: true }\n            );\n        }, 100);\n\n        this.map.once('moveend', (event: any) => {\n          if (event.fitboundComplete) {\n            resolve(true);\n          }\n        });\n      }\n    });\n  }\n\n  extendReBound(bottom?: number) {\n    return new Promise((resolve, reject) => {\n      this.bounds = new mapboxgl.LngLatBounds();\n\n      if (this.originDestinationCordinates.length >= 0) {\n        this.originDestinationCordinates.map((item: any, index: number) => {\n          item.map((route: any) => {\n            this.bounds.extend(route);\n          });\n          if (index === this.originDestinationCordinates.length - 1) {\n            const padding = {\n              top: this.padding.top + this.customTopForCustomer,\n              bottom:\n                this.padding.bottom +\n                (this.windowActualHeightWidth.availHeight -\n                  (window.innerHeight - 65)),\n              left: this.padding.left,\n              right: this.padding.right,\n            };\n            setTimeout(() => {\n              if (this.originDestinationCordinates.length > 0)\n                this.map.fitBounds(this.bounds, { padding, pitch: 65 });\n            }, 500);\n            resolve(true);\n          }\n        });\n      } else {\n        resolve(true);\n      }\n    });\n  }\n  plotRoute(\n    route: any,\n    i: number | any,\n    type: string,\n    enablefitbound?: boolean,\n    showAllFitbound?: boolean\n  ) {\n    return new Promise((resolve, reject) => {\n      let param: any = {};\n      if (['jobcode'].includes(type)) {\n        param['job'] = route['job_id'];\n        this.utils.postDataWithRestUrl('schedule/job/path', param).subscribe(\n          (res: any) => {\n            if (res['data']['route']) {\n              let path = res['data']['route'].split(';');\n              path = path.map((ele: string | any) => {\n                return (ele = this.formateLatLong(ele));\n              });\n              path.forEach((ele: any, index: number) => {\n                if (ele.length === 1) path.splice(index, 1);\n              });\n              route['path'] = path;\n              this.extendBound(route['path'], showAllFitbound);\n              if (route['path'] && route['path'].length > 0)\n                this.drawLine(route['path'], i, route, enablefitbound, type);\n                route['index'] = i;\n            } else {\n              this.extendBound(null, showAllFitbound);\n            }\n            resolve(true);\n          },\n          (err) => {\n            if (err) {\n              reject(false);\n            }\n          }\n        );\n      } else if (['jobrouteList', 'addroute'].includes(type)) {\n        if (route['path'] && route['path'].length > 0) {\n          let path = route['path'].split(';');\n          path = path.map((ele: string | any) => {\n            return (ele = this.formateLatLong(ele));\n          });\n          path.forEach((ele: any, index: number) => {\n            if (ele.length === 1) path.splice(index, 1);\n          });\n          this.extendBound(path, showAllFitbound);\n          this.drawLine(path, i, route, enablefitbound, type);\n        }\n      }\n    });\n  }\n  clearBound() {\n    this.bounds = new mapboxgl.LngLatBounds();\n    this.originDestinationCordinates = [];\n    this.clearPadding();\n  }\n  formateLatLong(latlong: string) {\n    return latlong\n      ? latlong\n          .split(',')\n          .map((x) => +x)\n          .reverse()\n      : null;\n  }\n  clearBoundWithCordinates() {\n    this.bounds = new mapboxgl.LngLatBounds();\n    this.originDestinationCordinates = [];\n  }\n\n  onResize(event: any) {\n    if (!this.bounds.isEmpty()) {\n      this.windowActualHeightWidth.availHeight =\n        window.innerHeight > window.screen.availHeight\n          ? window.innerHeight\n          : window.screen.availHeight;\n      setTimeout(() => {\n        this.map.fitBounds(this.bounds, {\n          padding: {\n            top: this.padding.top + this.customTopForCustomer,\n            bottom:\n              this.padding.bottom +\n              (this.windowActualHeightWidth.availHeight -\n                (event.target.innerHeight - 65)),\n            left: this.padding.left,\n            right: this.padding.right,\n          },\n          pitch: 65,\n        });\n      }, 500);\n    }\n  }\n\n  setWindowHeight(screen: any) {\n    this.windowActualHeightWidth.availHeight = screen;\n  }\n  setPadding(padding: any) {\n    this.padding = padding;\n  }\n  clearPadding() {\n    this.padding = null;\n  }\n  removeJobFromMap(data: Route[]) {\n    data.map((ele: any, index: number) => {\n      const id = ele['job_id'] ? ele['job_id'] : ele['route_id'];\n      this.removeRouteAndMarker(id);\n      if (index === data.length - 1) {\n        this.extendReBound();\n      }\n    });\n  }\n}\n"]}