ng-zenduit 1.0.0

package/esm2020/lib/services/geoconding.service.mjs

@@ -0,0 +1,61 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class GeocodingService {
+    setAPIKey(apiKey) {
+        this._platform = new H.service.Platform({
+            apikey: apiKey
+        });
+    }
+    async geocode(searchText) {
+        return new Promise((resolve, reject) => {
+            if (!this._platform) {
+                reject("API KEY NOT SET");
+                return;
+            }
+            const geocoder = this._platform.getGeocodingService();
+            geocoder.geocode({ searchText: searchText }, (res) => {
+                let locations = res.Response.View[0] ? res.Response.View[0].Result : [];
+                let outItems = new Array();
+                let boxOffset = 0.001;
+                for (let location of locations) {
+                    let lat = location.Location.DisplayPosition.Latitude;
+                    let lng = location.Location.DisplayPosition.Longitude;
+                    let p1 = new H.geo.Point(lat - boxOffset, lng - boxOffset);
+                    let p2 = new H.geo.Point(lat + boxOffset, lng + boxOffset);
+                    let bounds = H.geo.Rect.coverPoints([p1, p2]);
+                    let street = location.Location.Address.Street;
+                    if (location.Location.Address.HouseNumber) {
+                        street += " " + location.Location.Address.HouseNumber;
+                    }
+                    outItems.push({
+                        name: location.Location.Address.Label,
+                        city: location.Location.Address.City,
+                        country: location.Location.Address.Country,
+                        postalCode: location.Location.Address.PostalCode,
+                        state: location.Location.Address.State,
+                        street: street,
+                        bounds: {
+                            xmin: bounds.getLeft(),
+                            xmax: bounds.getRight(),
+                            ymin: Math.min(bounds.getBottom(), bounds.getTop()),
+                            ymax: Math.max(bounds.getBottom(), bounds.getTop())
+                        }
+                    });
+                }
+                resolve(outItems);
+            }, (e) => {
+                console.warn(e);
+                resolve([]);
+            });
+        });
+    }
+}
+GeocodingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: GeocodingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+GeocodingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: GeocodingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: GeocodingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/map.service.mjs

@@ -0,0 +1,181 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MapService {
+    createDeviceMarker(device, minZoom) {
+        const contentHtml = this.getDeviceContent(device);
+        const lat = Math.max(Math.min(device.latitude, 180), -180);
+        const lng = Math.max(Math.min(device.longitude, 180), -180);
+        const deviceMarker = new H.map.DomMarker(new H.geo.Point(lat, lng), {
+            zIndex: 10,
+            icon: new H.map.DomIcon(contentHtml),
+            data: device,
+            min: minZoom ? minZoom : 0
+        });
+        return deviceMarker;
+    }
+    getDeviceContent(device) {
+        let devIcon = "";
+        if (device.icon) {
+            devIcon = device.icon;
+        }
+        else {
+            // Default icon
+            devIcon = "https://storage.googleapis.com/ng-zenduit/icon/car.svg";
+        }
+        let isDriving = device.isDriving || false;
+        let driveClass = "";
+        if (isDriving) {
+            driveClass = "driving-marker";
+        }
+        let directionSvg = 'https://storage.googleapis.com/ng-zenduit/icon/device_direction.svg';
+        let displayDirection = isDriving ? "block" : "none";
+        let classList = isDriving ? "moving" : "stopped";
+        const lblContent = `<div class='gotrax-label ${classList}'>` +
+            `  <span>${device.name}</span>` +
+            `  <div class='gotrax-speed-label'></div>` +
+            `</div>`;
+        const bearing = device.bearing || 0;
+        let contentHtml = `<div>` +
+            `<div class='g-marker-vehilce-wrapper'>` +
+            `<div class='g-marker-vehilce'>` +
+            `<div class='${driveClass} gotrax-img'>
+            ${lblContent}
+            <div class='g-marker-icon ${classList}'><img class="g-marker-img svg-color white" src=${devIcon} />
+            <div class="direction-arrow" style="display: ${displayDirection};transform: rotate(${bearing}deg); background-image: url('${directionSvg}');"></div>
+            </div></div>` +
+            `</div>` + // close g-marker-vehilce
+            `</div>` + // close g-marker-vehilce-wrapper
+            `</div>`;
+        return contentHtml;
+    }
+    zoomToBounds(map, bounds) {
+        if (!bounds || bounds.isEmpty()) {
+            return;
+        }
+        if (isNaN(bounds.getCenter().lat) ||
+            isNaN(bounds.getCenter().lng)) {
+            return;
+        }
+        this.zoomToLatLngs(map, [bounds.getTopLeft(), bounds.getBottomRight()]);
+    }
+    zoomToLatLngs(map, pnts, zoom = 15) {
+        if (!pnts || pnts.length == 0) {
+            return;
+        }
+        if (pnts.length == 1) {
+            map.setZoom(zoom);
+            map.setCenter(new H.geo.Point(pnts[0].lat, pnts[0].lng));
+            return;
+        }
+        const latLngs = [];
+        pnts.forEach(p => latLngs.push(p.lat, p.lng, 0));
+        const bounds = H.geo.Rect.coverLatLngAlts(latLngs);
+        const minSize = 0.001;
+        if (bounds.getWidth() < minSize &&
+            bounds.getHeight() < minSize) {
+            map.setCenter(bounds.getCenter());
+            map.setZoom(17);
+        }
+        else {
+            const p1 = bounds.getBottomRight();
+            const p2 = bounds.getTopLeft();
+            const width = Math.max(bounds.getWidth(), minSize);
+            const height = Math.max(bounds.getHeight(), minSize);
+            // add offset for zooming
+            const targetBox = H.geo.Rect.coverLatLngAlts([
+                p1.lat - (height * 0.15),
+                p2.lng - (width * 0.15),
+                0,
+                p2.lat + (height * 0.15),
+                p1.lng + (width * 0.15),
+                0
+            ]);
+            map.getViewPort().resize();
+            map.getViewModel().setLookAtData({ bounds: targetBox });
+        }
+    }
+    /**
+     * Create polylines for given trip and date range.
+     * Method create separte polylines for logs outside the date range.
+     */
+    createTripPolyline(trip, map, theme) {
+        let result = {};
+        let coords = new Array();
+        trip.logs.forEach(log => {
+            let latLng = new H.geo.Point(log.latitude, log.longitude);
+            coords.push(latLng.lat, latLng.lng);
+        });
+        if (coords.length < 2) {
+            // Skip the empty path
+            return result;
+        }
+        if (theme == "black") {
+            const pl = this.createPl(coords, "#000000", 2);
+            pl.setZIndex(1);
+            result.polyline = pl;
+            map.addObject(pl);
+        }
+        else {
+            const pl = this.createPl(coords, "#9510e6", 5);
+            pl.setZIndex(1);
+            result.polyline = pl;
+            let arrow = this.createArrow(coords);
+            result.arrows = arrow;
+            map.addObjects([pl, arrow]);
+            // store additional information about polyline
+            pl.setData({ type: "trip", trip: trip });
+            arrow.setData({ type: "trip", trip: trip });
+        }
+        return result;
+    }
+    createPl(coords, color, strokeWeight) {
+        const pl = new H.map.Polyline(H.geo.LineString.fromLatLngArray(coords), {
+            style: {
+                strokeColor: color,
+                lineWidth: strokeWeight
+            },
+            arrows: {
+                fillColor: "#ffffff"
+            },
+            zIndex: 0
+        });
+        return pl;
+    }
+    createArrow(coords) {
+        return new H.map.Polyline(H.geo.LineString.fromLatLngArray(coords), {
+            style: {
+                lineWidth: 5,
+                fillColor: 'white',
+                strokeColor: 'rgba(255, 255, 255, 1)',
+                lineDash: [0, 5],
+                lineTailCap: 'arrow-tail',
+                lineHeadCap: 'arrow-head'
+            },
+            zIndex: 1
+        });
+    }
+    createStopMarker(map, log, stopIdx, tag, theme) {
+        let icon;
+        if (theme == "black") {
+            const src = "https://storage.googleapis.com/ng-zenduit/icon/stop-icon-black.svg";
+            icon = new H.map.DomIcon(`<div class="g-stop-img"><img src="${src}"/></div>`);
+        }
+        else {
+            // deafault
+            icon = new H.map.DomIcon(`<div class="g-stop"><label>${stopIdx}</label></div>`);
+        }
+        let stop = new H.map.DomMarker(new H.geo.Point(log.latitude, log.longitude), {
+            icon: icon,
+            zIndex: 2
+        });
+        map.addObject(stop);
+        stop.setData(tag);
+        return stop;
+    }
+}
+MapService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MapService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MapService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MapService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: MapService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"map.service.js","sourceRoot":"","sources":["../../../../../projects/ng-zenduit/src/lib/services/map.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAI3C,MAAM,OAAO,UAAU;IAEZ,kBAAkB,CAAC,MAAiB,EAAE,OAAgB;QACzD,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAElD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAC3D,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAE5D,MAAM,YAAY,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,SAAS,CACpC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EACzB;YACI,MAAM,EAAE,EAAE;YACV,IAAI,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC;YACpC,IAAI,EAAE,MAAM;YACZ,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;SAC7B,CAAC,CAAC;QAEP,OAAO,YAAY,CAAC;IACxB,CAAC;IAEO,gBAAgB,CAAC,MAAiB;QACtC,IAAI,OAAO,GAAG,EAAE,CAAC;QAEjB,IAAI,MAAM,CAAC,IAAI,EAAE;YACb,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;SACzB;aACI;YACD,eAAe;YACf,OAAO,GAAG,wDAAwD,CAAC;SACtE;QAED,IAAI,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,KAAK,CAAC;QAC1C,IAAI,UAAU,GAAG,EAAE,CAAC;QACpB,IAAI,SAAS,EAAE;YACX,UAAU,GAAG,gBAAgB,CAAC;SACjC;QAGD,IAAI,YAAY,GAAG,qEAAqE,CAAC;QAEzF,IAAI,gBAAgB,GAAG,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;QAEpD,IAAI,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;QAEjD,MAAM,UAAU,GACZ,4BAA4B,SAAS,IAAI;YACzC,WAAW,MAAM,CAAC,IAAI,SAAS;YAC/B,0CAA0C;YAC1C,QAAQ,CAAC;QAEb,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,CAAC,CAAC;QAEpC,IAAI,WAAW,GACX,OAAO;YACP,wCAAwC;YACxC,gCAAgC;YAChC,eAAe,UAAU;cACvB,UAAU;wCACgB,SAAS,mDAAmD,OAAO;2DAChD,gBAAgB,sBAAsB,OAAO,gCAAgC,YAAY;yBAC3H;YACb,QAAQ,GAAE,yBAAyB;YACnC,QAAQ,GAAG,iCAAiC;YAC5C,QAAQ,CAAC;QACb,OAAO,WAAW,CAAC;IACvB,CAAC;IAGM,YAAY,CAAC,GAAU,EAAE,MAAkB;QAC9C,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,EAAE,EAAE;YAC7B,OAAO;SACV;QAED,IAAI,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC;YAC7B,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,GAAG,CAAC,EAAE;YAC/B,OAAO;SACV;QAED,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAEO,aAAa,CAAC,GAAU,EAAE,IAAyC,EAAE,OAAe,EAAE;QAE1F,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE;YAC3B,OAAO;SACV;QACD,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE;YAClB,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAClB,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACzD,OAAO;SACV;QAED,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjD,MAAM,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAe,CAAC;QAEjE,MAAM,OAAO,GAAG,KAAK,CAAC;QAEtB,IAAI,MAAM,CAAC,QAAQ,EAAE,GAAG,OAAO;YAC3B,MAAM,CAAC,SAAS,EAAE,GAAG,OAAO,EAAE;YAC9B,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;YAClC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;SACnB;aACI;YACD,MAAM,EAAE,GAAG,MAAM,CAAC,cAAc,EAAE,CAAC;YACnC,MAAM,EAAE,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;YAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC;YACnD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,OAAO,CAAC,CAAC;YAErD,yBAAyB;YACzB,MAAM,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CACxC;gBACI,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC;gBACxB,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC;gBACvB,CAAC;gBACD,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC;gBACxB,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC;gBACvB,CAAC;aACJ,CACU,CAAC;YAEhB,GAAG,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,CAAC;YAC3B,GAAG,CAAC,YAAY,EAAE,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;SAC3D;IACL,CAAC;IAED;;;OAGG;IACI,kBAAkB,CAAC,IAAa,EAAE,GAAU,EAAE,KAAkB;QAKnE,IAAI,MAAM,GAAG,EAIZ,CAAC;QAEF,IAAI,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC;QAEjC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACpB,IAAI,MAAM,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;YAE1D,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACnB,sBAAsB;YACtB,OAAO,MAAM,CAAC;SACjB;QAED,IAAI,KAAK,IAAI,OAAO,EAAE;YAClB,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YAC/C,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAChB,MAAM,CAAC,QAAQ,GAAG,EAAE,CAAC;YAErB,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;SACrB;aACI;YACD,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YAC/C,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAChB,MAAM,CAAC,QAAQ,GAAG,EAAE,CAAC;YAErB,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACrC,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC;YAEtB,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;YAE5B,8CAA8C;YAC9C,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YACzC,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;SAC/C;QAGD,OAAO,MAAM,CAAC;IAClB,CAAC;IAEO,QAAQ,CAAC,MAAqB,EAAE,KAAa,EAAE,YAAoB;QACvE,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,QAAQ,CACzB,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,MAAM,CAAC,EACxC;YACI,KAAK,EAAE;gBACH,WAAW,EAAE,KAAK;gBAClB,SAAS,EAAE,YAAY;aAC1B;YACD,MAAM,EAAE;gBACJ,SAAS,EAAE,SAAS;aACvB;YACD,MAAM,EAAE,CAAC;SACZ,CAAC,CAAC;QACP,OAAO,EAAE,CAAC;IACd,CAAC;IAEO,WAAW,CAAC,MAAqB;QACrC,OAAO,IAAI,CAAC,CAAC,GAAG,CAAC,QAAQ,CACrB,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC,MAAM,CAAC,EACxC;YACI,KAAK,EAAE;gBACH,SAAS,EAAE,CAAC;gBACZ,SAAS,EAAE,OAAO;gBAClB,WAAW,EAAE,wBAAwB;gBACrC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;gBAChB,WAAW,EAAE,YAAY;gBACzB,WAAW,EAAE,YAAY;aACrB;YACR,MAAM,EAAE,CAAC;SACZ,CAAC,CAAC;IACX,CAAC;IAEM,gBAAgB,CAAC,GAAU,EAAE,GAAiB,EAAE,OAAe,EAAE,GAAQ,EAAE,KAAkB;QAEhG,IAAI,IAAmB,CAAC;QACxB,IAAI,KAAK,IAAI,OAAO,EAAE;YAClB,MAAM,GAAG,GAAG,oEAAoE,CAAC;YACjF,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,qCAAqC,GAAG,WAAW,CAAC,CAAA;SAChF;aACI;YACD,WAAW;YACX,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,8BAA8B,OAAO,gBAAgB,CAAC,CAAA;SAClF;QAED,IAAI,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,SAAS,CAC1B,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,SAAS,CAAC,EAC5C;YACI,IAAI,EAAE,IAAI;YACV,MAAM,EAAE,CAAC;SACZ,CAAC,CAAC;QACP,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACpB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAClB,OAAO,IAAI,CAAC;IAChB,CAAC;;wGA1OQ,UAAU;4GAAV,UAAU;4FAAV,UAAU;kBADtB,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ZenDevice, ZenLogRecord, ZenMapTheme, ZenTrip } from '../map/map.types';\n\n@Injectable()\nexport class MapService {\n\n    public createDeviceMarker(device: ZenDevice, minZoom?: number): H.map.DomMarker {\n        const contentHtml = this.getDeviceContent(device);\n\n        const lat = Math.max(Math.min(device.latitude, 180), -180);\n        const lng = Math.max(Math.min(device.longitude, 180), -180);\n\n        const deviceMarker = new H.map.DomMarker(\n            new H.geo.Point(lat, lng),\n            {\n                zIndex: 10,\n                icon: new H.map.DomIcon(contentHtml),\n                data: device,\n                min: minZoom ? minZoom : 0\n            });\n\n        return deviceMarker;\n    }\n\n    private getDeviceContent(device: ZenDevice): string {\n        let devIcon = \"\";\n\n        if (device.icon) {\n            devIcon = device.icon;\n        }\n        else {\n            // Default icon\n            devIcon = \"https://storage.googleapis.com/ng-zenduit/icon/car.svg\";\n        }\n\n        let isDriving = device.isDriving || false;\n        let driveClass = \"\";\n        if (isDriving) {\n            driveClass = \"driving-marker\";\n        }\n\n\n        let directionSvg = 'https://storage.googleapis.com/ng-zenduit/icon/device_direction.svg';\n\n        let displayDirection = isDriving ? \"block\" : \"none\";\n\n        let classList = isDriving ? \"moving\" : \"stopped\";\n\n        const lblContent =\n            `<div class='gotrax-label ${classList}'>` +\n            `  <span>${device.name}</span>` +\n            `  <div class='gotrax-speed-label'></div>` +\n            `</div>`;\n\n        const bearing = device.bearing || 0;\n\n        let contentHtml =\n            `<div>` +\n            `<div class='g-marker-vehilce-wrapper'>` +\n            `<div class='g-marker-vehilce'>` +\n            `<div class='${driveClass} gotrax-img'>\n            ${lblContent}\n            <div class='g-marker-icon ${classList}'><img class=\"g-marker-img svg-color white\" src=${devIcon} />\n            <div class=\"direction-arrow\" style=\"display: ${displayDirection};transform: rotate(${bearing}deg); background-image: url('${directionSvg}');\"></div>\n            </div></div>` +\n            `</div>` +// close g-marker-vehilce\n            `</div>` + // close g-marker-vehilce-wrapper\n            `</div>`;\n        return contentHtml;\n    }\n\n\n    public zoomToBounds(map: H.Map, bounds: H.geo.Rect) {\n        if (!bounds || bounds.isEmpty()) {\n            return;\n        }\n\n        if (isNaN(bounds.getCenter().lat) ||\n            isNaN(bounds.getCenter().lng)) {\n            return;\n        }\n\n        this.zoomToLatLngs(map, [bounds.getTopLeft(), bounds.getBottomRight()]);\n    }\n\n    private zoomToLatLngs(map: H.Map, pnts: Array<{ lat: number, lng: number }>, zoom: number = 15) {\n\n        if (!pnts || pnts.length == 0) {\n            return;\n        }\n        if (pnts.length == 1) {\n            map.setZoom(zoom);\n            map.setCenter(new H.geo.Point(pnts[0].lat, pnts[0].lng));\n            return;\n        }\n\n        const latLngs: number[] = [];\n        pnts.forEach(p => latLngs.push(p.lat, p.lng, 0));\n\n        const bounds = H.geo.Rect.coverLatLngAlts(latLngs) as H.geo.Rect;\n\n        const minSize = 0.001;\n\n        if (bounds.getWidth() < minSize &&\n            bounds.getHeight() < minSize) {\n            map.setCenter(bounds.getCenter());\n            map.setZoom(17);\n        }\n        else {\n            const p1 = bounds.getBottomRight();\n            const p2 = bounds.getTopLeft();\n            const width = Math.max(bounds.getWidth(), minSize);\n            const height = Math.max(bounds.getHeight(), minSize);\n\n            // add offset for zooming\n            const targetBox = H.geo.Rect.coverLatLngAlts(\n                [\n                    p1.lat - (height * 0.15),\n                    p2.lng - (width * 0.15),\n                    0,\n                    p2.lat + (height * 0.15),\n                    p1.lng + (width * 0.15),\n                    0\n                ]\n            ) as H.geo.Rect;\n\n            map.getViewPort().resize();\n            map.getViewModel().setLookAtData({ bounds: targetBox });\n        }\n    }\n\n    /**\n     * Create polylines for given trip and date range.\n     * Method create separte polylines for logs outside the date range.\n     */\n    public createTripPolyline(trip: ZenTrip, map: H.Map, theme: ZenMapTheme): {\n        polyline: H.map.Polyline,\n        arrows: H.map.Polyline\n    } {\n\n        let result = {\n        } as {\n            polyline: H.map.Polyline,\n            arrows: H.map.Polyline\n        };\n\n        let coords = new Array<number>();\n\n        trip.logs.forEach(log => {\n            let latLng = new H.geo.Point(log.latitude, log.longitude);\n\n            coords.push(latLng.lat, latLng.lng);\n        });\n\n        if (coords.length < 2) {\n            // Skip the empty path\n            return result;\n        }\n\n        if (theme == \"black\") {\n            const pl = this.createPl(coords, \"#000000\", 2);\n            pl.setZIndex(1);\n            result.polyline = pl;\n\n            map.addObject(pl);\n        }\n        else {\n            const pl = this.createPl(coords, \"#9510e6\", 5);\n            pl.setZIndex(1);\n            result.polyline = pl;\n\n            let arrow = this.createArrow(coords);\n            result.arrows = arrow;\n\n            map.addObjects([pl, arrow]);\n\n            // store additional information about polyline\n            pl.setData({ type: \"trip\", trip: trip });\n            arrow.setData({ type: \"trip\", trip: trip });\n        }\n\n\n        return result;\n    }\n\n    private createPl(coords: Array<number>, color: string, strokeWeight: number): H.map.Polyline {\n        const pl = new H.map.Polyline(\n            H.geo.LineString.fromLatLngArray(coords),\n            {\n                style: {\n                    strokeColor: color,\n                    lineWidth: strokeWeight\n                },\n                arrows: {\n                    fillColor: \"#ffffff\"\n                },\n                zIndex: 0\n            });\n        return pl;\n    }\n\n    private createArrow(coords: Array<number>): H.map.Polyline {\n        return new H.map.Polyline(\n            H.geo.LineString.fromLatLngArray(coords),\n            {\n                style: {\n                    lineWidth: 5,\n                    fillColor: 'white',\n                    strokeColor: 'rgba(255, 255, 255, 1)',\n                    lineDash: [0, 5],\n                    lineTailCap: 'arrow-tail',\n                    lineHeadCap: 'arrow-head'\n                } as any,\n                zIndex: 1\n            });\n    }\n\n    public createStopMarker(map: H.Map, log: ZenLogRecord, stopIdx: number, tag: any, theme: ZenMapTheme) {\n\n        let icon: H.map.DomIcon;\n        if (theme == \"black\") {\n            const src = \"https://storage.googleapis.com/ng-zenduit/icon/stop-icon-black.svg\";\n            icon = new H.map.DomIcon(`<div class=\"g-stop-img\"><img src=\"${src}\"/></div>`)\n        }\n        else {\n            // deafault\n            icon = new H.map.DomIcon(`<div class=\"g-stop\"><label>${stopIdx}</label></div>`)\n        }\n\n        let stop = new H.map.DomMarker(\n            new H.geo.Point(log.latitude, log.longitude),\n            {\n                icon: icon,\n                zIndex: 2\n            });\n        map.addObject(stop);\n        stop.setData(tag);\n        return stop;\n    }\n}"]}

package/esm2020/lib/services/opencv.service.mjs

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import { LocalLock } from '../local.lock';
+import { Util } from '../util';
+import * as i0 from "@angular/core";
+export class OpenCVService {
+    /**
+     * extract paper from the image
+     * @returns
+     */
+    async extractPaper(options) {
+        // load open cv
+        await this.loadOpenCv();
+        const htmlImage = await this.loadImage(options.src);
+        console.log("image is ready");
+        const scanner = new window["jscanify"];
+        return scanner.extractPaper(htmlImage, options.height, options.width, options.corners);
+    }
+    /**
+     * Get the paper corners from the specific image
+     * @param src
+     * @returns
+     */
+    async getPaperCorners(src, height, width) {
+        // load opencv
+        await this.loadOpenCv();
+        const cv = this.getCVInternal();
+        const htmlImage = await this.loadImage(src);
+        console.log("image is ready", htmlImage);
+        const scanner = new window["jscanify"];
+        const img = cv.imread(htmlImage);
+        const maxContour = scanner.findPaperContour(img);
+        if (!maxContour) {
+            return null;
+        }
+        const res = scanner.getCornerPoints(maxContour, img);
+        return res;
+    }
+    loadImage(src) {
+        return new Promise((resolve) => {
+            const image = new Image();
+            image.src = src;
+            image.onload = function () {
+                resolve(image);
+            };
+        });
+    }
+    async loadOpenCv() {
+        try {
+            await OpenCVService._lock.lock();
+            if (OpenCVService._isOpenCVLoaded) {
+                return;
+            }
+            console.log("load opencv...");
+            // Storage bucket available here:
+            // https://console.cloud.google.com/storage/browser/ng-zenduit/scripts?project=zendu-one
+            // load open cv script
+            this.loadScript("https://storage.googleapis.com/ng-zenduit/scripts/opencv_4.7.0.js");
+            await this.waitInitalization("cv");
+            // load jscanify script
+            this.loadScript("https://storage.googleapis.com/ng-zenduit/scripts/jscanify_1.2.0.js");
+            await this.waitInitalization("jscanify");
+            console.log("OpenCV is ready");
+            OpenCVService._isOpenCVLoaded = true;
+        }
+        finally {
+            OpenCVService._lock.release();
+        }
+    }
+    loadScript(src) {
+        const script = document.createElement('script');
+        script.setAttribute('type', 'text/javascript');
+        script.src = src;
+        // insert script to document
+        const node = document.getElementsByTagName('script')[0];
+        if (node) {
+            node.parentNode.insertBefore(script, node);
+        }
+        else {
+            document.head.appendChild(script);
+        }
+    }
+    async waitInitalization(globalVarName) {
+        const timeout = Date.now() + 60000;
+        // wait cv first
+        while (true) {
+            if (window[globalVarName]) {
+                break;
+            }
+            await Util.sleep(1000);
+            if (Date.now() > timeout) {
+                throw `Failed initalize OpenCV. Reason: timeout`;
+            }
+        }
+    }
+    getCVInternal() {
+        return window["cv"];
+    }
+}
+OpenCVService._isOpenCVLoaded = false;
+OpenCVService._lock = new LocalLock();
+OpenCVService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: OpenCVService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+OpenCVService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: OpenCVService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: OpenCVService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"opencv.service.js","sourceRoot":"","sources":["../../../../../projects/ng-zenduit/src/lib/services/opencv.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { LocalLock } from '../local.lock';\nimport { Util } from '../util';\n\nexport interface ScanifyCorners {\n    topLeftCorner: { x: number, y: number };\n    topRightCorner: { x: number, y: number };\n    bottomLeftCorner: { x: number, y: number };\n    bottomRightCorner: { x: number, y: number };\n}\n\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class OpenCVService {\n\n    private static _isOpenCVLoaded = false;\n\n    private static _lock = new LocalLock();\n\n    /**\n     * extract paper from the image\n     * @returns\n     */\n    public async extractPaper(options: {\n        src: string;\n        height: number;\n        width: number;\n        corners: ScanifyCorners;\n    }): Promise<HTMLCanvasElement> {\n        // load open cv\n        await this.loadOpenCv();\n\n        const htmlImage = await this.loadImage(options.src);\n        console.log(\"image is ready\");\n\n        const scanner = new window[\"jscanify\"];\n\n        return scanner.extractPaper(htmlImage, options.height, options.width, options.corners);\n    }\n\n    /**\n     * Get the paper corners from the specific image\n     * @param src\n     * @returns\n     */\n    public async getPaperCorners(src: string,height:number, width:number): Promise<ScanifyCorners> {\n        // load opencv\n        await this.loadOpenCv();\n\n        const cv = this.getCVInternal();\n\n        const htmlImage = await this.loadImage(src);\n        console.log(\"image is ready\", htmlImage);\n\n        const scanner = new window[\"jscanify\"];\n\n        const img = cv.imread(htmlImage);\n\n        const maxContour = scanner.findPaperContour(img);\n        if (!maxContour) {\n            return null;\n        }\n\n        const res = scanner.getCornerPoints(maxContour, img);\n        return res;\n    }\n\n    private loadImage(src: string) {\n        return new Promise((resolve) => {\n            const image = new Image();\n            image.src = src;\n            image.onload = function () {\n                resolve(image);\n            };\n        })\n\n    }\n\n    private async loadOpenCv() {\n        try {\n            await OpenCVService._lock.lock();\n\n            if (OpenCVService._isOpenCVLoaded) {\n                return;\n            }\n\n            console.log(\"load opencv...\")\n\n            // Storage bucket available here:\n            // https://console.cloud.google.com/storage/browser/ng-zenduit/scripts?project=zendu-one\n\n            // load open cv script\n            this.loadScript(\"https://storage.googleapis.com/ng-zenduit/scripts/opencv_4.7.0.js\");\n            await this.waitInitalization(\"cv\");\n\n            // load jscanify script\n            this.loadScript(\"https://storage.googleapis.com/ng-zenduit/scripts/jscanify_1.2.0.js\");\n            await this.waitInitalization(\"jscanify\");\n\n            console.log(\"OpenCV is ready\")\n\n            OpenCVService._isOpenCVLoaded = true;\n        }\n        finally {\n            OpenCVService._lock.release();\n        }\n    }\n\n    private loadScript(src: string) {\n        const script = <HTMLScriptElement>document.createElement('script');\n        script.setAttribute('type', 'text/javascript');\n\n        script.src = src;\n        // insert script to document\n        const node = document.getElementsByTagName('script')[0];\n        if (node) {\n            node.parentNode.insertBefore(script, node);\n        } else {\n            document.head.appendChild(script);\n        }\n    }\n\n    private async waitInitalization(globalVarName: string) {\n\n        const timeout = Date.now() + 60000;\n\n        // wait cv first\n        while (true) {\n            if (window[globalVarName]) {\n                break;\n            }\n            await Util.sleep(1000);\n\n            if (Date.now() > timeout) {\n                throw `Failed initalize OpenCV. Reason: timeout`\n            }\n        }\n    }\n\n    private getCVInternal() {\n        return window[\"cv\"];\n    }\n}\n"]}

package/esm2020/lib/services/zendu-notify.service.mjs

@@ -0,0 +1,92 @@
+import { Injectable } from '@angular/core';
+import { show as showSnackbar } from "node-snackbar";
+import * as i0 from "@angular/core";
+export class ZenNotifyService {
+    info(msg, duration = 5000, hasDismiss = true) {
+        console.log(msg);
+        showSnackbar({
+            pos: "top-center",
+            text: msg,
+            textColor: "white",
+            duration: duration,
+            actionText: "dismiss",
+            actionTextColor: "white",
+            showAction: hasDismiss
+        });
+    }
+    success(msg, duration = 5000, hasDismiss = true) {
+        console.log(msg);
+        showSnackbar({
+            pos: "top-center",
+            text: msg,
+            textColor: "white",
+            backgroundColor: "#5cbb3a",
+            duration: duration,
+            actionText: "dismiss",
+            actionTextColor: "white",
+            showAction: hasDismiss
+        });
+    }
+    warn(msg, duration = 5000, hasDismiss = true) {
+        console.warn(msg);
+        showSnackbar({
+            pos: "top-center",
+            text: msg,
+            textColor: "white",
+            backgroundColor: "#f1b10b",
+            duration: duration,
+            actionText: "dismiss",
+            actionTextColor: "white",
+            showAction: hasDismiss
+        });
+    }
+    error(err, duration = 5000, hasDismiss = true) {
+        console.error(err);
+        showSnackbar({
+            pos: "top-center",
+            text: this.getErrorMessage(err),
+            textColor: "white",
+            backgroundColor: "#dc3e33",
+            duration: duration,
+            actionText: "dismiss",
+            actionTextColor: "white",
+            showAction: hasDismiss
+        });
+    }
+    getErrorMessage(ex) {
+        if (!ex) {
+            return '';
+        }
+        if (typeof ex === 'string') {
+            return ex;
+        }
+        else if (typeof ex.error === 'string') {
+            return ex.error;
+        }
+        else if (ex.error && ex.error.message) {
+            return ex.error.message;
+        }
+        else if (ex.message) {
+            return ex.message;
+        }
+        else if (ex.status && ex.statusText) {
+            return `Http error ${ex.status} ${ex.statusText}`;
+        }
+        else if (ex.statusText) {
+            return ex.statusText;
+        }
+        else {
+            console.warn('Can\'t extract error message from object:', ex);
+            return '';
+        }
+    }
+}
+ZenNotifyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenNotifyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ZenNotifyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenNotifyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenNotifyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/sort-header/zendu-sort-header.component.mjs

@@ -0,0 +1,36 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ZenduSortHeaderComponent {
+    constructor() {
+        this.sortChange = new EventEmitter();
+    }
+    toggleSort() {
+        switch (this.sort) {
+            case 'asc':
+                this.sort = 'desc';
+                this.sortChange.emit(this.sort);
+                break;
+            case 'desc':
+                this.sort = 'asc';
+                this.sortChange.emit(this.sort);
+                break;
+            default:
+                this.sort = 'asc';
+                this.sortChange.emit(this.sort);
+        }
+    }
+}
+ZenduSortHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduSortHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ZenduSortHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: ZenduSortHeaderComponent, selector: "zen-sort", inputs: { sort: "sort", active: "active" }, outputs: { sortChange: "sortChange" }, ngImport: i0, template: "<div class=\"sort-option\"\n     (click)=\"toggleSort()\">\n   <div>\n      <i class=\"material-icons sort-icon\"\n         [ngClass]=\"active && sort === 'asc' ? 'sort-icon-active' : ''\">\n         keyboard_arrow_up\n      </i>\n   </div>\n   <div>\n      <i class=\"material-icons sort-icon\"\n         [ngClass]=\"active && sort === 'desc' ? 'sort-icon-active' : ''\">\n         keyboard_arrow_down\n      </i>\n   </div>\n</div>\n", styles: [".sort-option{display:flex;flex-direction:column;cursor:pointer;-webkit-user-select:none;user-select:none}.sort-option .sort-icon{display:flex;color:#cfe9fd;height:10px;align-items:center;font-weight:500;font-size:20px;transition:.3s}.sort-option .sort-icon-active{color:#2188d9}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduSortHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'zen-sort', template: "<div class=\"sort-option\"\n     (click)=\"toggleSort()\">\n   <div>\n      <i class=\"material-icons sort-icon\"\n         [ngClass]=\"active && sort === 'asc' ? 'sort-icon-active' : ''\">\n         keyboard_arrow_up\n      </i>\n   </div>\n   <div>\n      <i class=\"material-icons sort-icon\"\n         [ngClass]=\"active && sort === 'desc' ? 'sort-icon-active' : ''\">\n         keyboard_arrow_down\n      </i>\n   </div>\n</div>\n", styles: [".sort-option{display:flex;flex-direction:column;cursor:pointer;-webkit-user-select:none;user-select:none}.sort-option .sort-icon{display:flex;color:#cfe9fd;height:10px;align-items:center;font-weight:500;font-size:20px;transition:.3s}.sort-option .sort-icon-active{color:#2188d9}\n"] }]
+        }], propDecorators: { sort: [{
+                type: Input
+            }], sortChange: [{
+                type: Output
+            }], active: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemVuZHUtc29ydC1oZWFkZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctemVuZHVpdC9zcmMvbGliL3NvcnQtaGVhZGVyL3plbmR1LXNvcnQtaGVhZGVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXplbmR1aXQvc3JjL2xpYi9zb3J0LWhlYWRlci96ZW5kdS1zb3J0LWhlYWRlci5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxLQUFLLEVBQWEsTUFBTSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7O0FBT2pHLE1BQU0sT0FBTyx3QkFBd0I7SUFMckM7UUFTWSxlQUFVLEdBQUcsSUFBSSxZQUFZLEVBQWtCLENBQUM7S0FtQjNEO0lBZlEsVUFBVTtRQUNmLFFBQVEsSUFBSSxDQUFDLElBQUksRUFBRTtZQUNqQixLQUFLLEtBQUs7Z0JBQ1IsSUFBSSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUM7Z0JBQ25CLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDaEMsTUFBTTtZQUNSLEtBQUssTUFBTTtnQkFDVCxJQUFJLENBQUMsSUFBSSxHQUFHLEtBQUssQ0FBQztnQkFDbEIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUNoQyxNQUFNO1lBQ1I7Z0JBQ0UsSUFBSSxDQUFDLElBQUksR0FBRyxLQUFLLENBQUM7Z0JBQ2xCLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUNuQztJQUNILENBQUM7O3NIQXRCVSx3QkFBd0I7MEdBQXhCLHdCQUF3QixtSUNQckMscWJBZUE7NEZEUmEsd0JBQXdCO2tCQUxwQyxTQUFTOytCQUNFLFVBQVU7OEJBTVgsSUFBSTtzQkFBWixLQUFLO2dCQUVJLFVBQVU7c0JBQW5CLE1BQU07Z0JBRUUsTUFBTTtzQkFBZCxLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBFdmVudEVtaXR0ZXIsIElucHV0LCBPbkNoYW5nZXMsIE91dHB1dCwgU2ltcGxlQ2hhbmdlcyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICd6ZW4tc29ydCcsXG4gIHRlbXBsYXRlVXJsOiAnLi96ZW5kdS1zb3J0LWhlYWRlci5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3plbmR1LXNvcnQtaGVhZGVyLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgWmVuZHVTb3J0SGVhZGVyQ29tcG9uZW50IHtcblxuICBASW5wdXQoKSBzb3J0ITogJ2FzYycgfCAnZGVzYycgfCAnJztcblxuICBAT3V0cHV0KCkgc29ydENoYW5nZSA9IG5ldyBFdmVudEVtaXR0ZXI8J2FzYycgfCAnZGVzYyc+KCk7XG5cbiAgQElucHV0KCkgYWN0aXZlITogYm9vbGVhbjtcblxuICBwdWJsaWMgdG9nZ2xlU29ydCgpIHtcbiAgICBzd2l0Y2ggKHRoaXMuc29ydCkge1xuICAgICAgY2FzZSAnYXNjJzpcbiAgICAgICAgdGhpcy5zb3J0ID0gJ2Rlc2MnO1xuICAgICAgICB0aGlzLnNvcnRDaGFuZ2UuZW1pdCh0aGlzLnNvcnQpO1xuICAgICAgICBicmVhaztcbiAgICAgIGNhc2UgJ2Rlc2MnOlxuICAgICAgICB0aGlzLnNvcnQgPSAnYXNjJztcbiAgICAgICAgdGhpcy5zb3J0Q2hhbmdlLmVtaXQodGhpcy5zb3J0KTtcbiAgICAgICAgYnJlYWs7XG4gICAgICBkZWZhdWx0OlxuICAgICAgICB0aGlzLnNvcnQgPSAnYXNjJztcbiAgICAgICAgdGhpcy5zb3J0Q2hhbmdlLmVtaXQodGhpcy5zb3J0KTtcbiAgICB9XG4gIH1cbn1cbiIsIjxkaXYgY2xhc3M9XCJzb3J0LW9wdGlvblwiXG4gICAgIChjbGljayk9XCJ0b2dnbGVTb3J0KClcIj5cbiAgIDxkaXY+XG4gICAgICA8aSBjbGFzcz1cIm1hdGVyaWFsLWljb25zIHNvcnQtaWNvblwiXG4gICAgICAgICBbbmdDbGFzc109XCJhY3RpdmUgJiYgc29ydCA9PT0gJ2FzYycgPyAnc29ydC1pY29uLWFjdGl2ZScgOiAnJ1wiPlxuICAgICAgICAga2V5Ym9hcmRfYXJyb3dfdXBcbiAgICAgIDwvaT5cbiAgIDwvZGl2PlxuICAgPGRpdj5cbiAgICAgIDxpIGNsYXNzPVwibWF0ZXJpYWwtaWNvbnMgc29ydC1pY29uXCJcbiAgICAgICAgIFtuZ0NsYXNzXT1cImFjdGl2ZSAmJiBzb3J0ID09PSAnZGVzYycgPyAnc29ydC1pY29uLWFjdGl2ZScgOiAnJ1wiPlxuICAgICAgICAga2V5Ym9hcmRfYXJyb3dfZG93blxuICAgICAgPC9pPlxuICAgPC9kaXY+XG48L2Rpdj5cbiJdfQ==

package/esm2020/lib/spinner/zendu-spinner.component.mjs

@@ -0,0 +1,11 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ZenduSpinner {
+}
+ZenduSpinner.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduSpinner, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ZenduSpinner.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: ZenduSpinner, selector: "zen-spinner", ngImport: i0, template: "<div class=\"component\">\n</div>\n", styles: [".component{width:64px;height:64px;border:6px solid var(--color-primary, #2188d9);border-bottom-color:transparent;border-radius:50%;display:inline-block;box-sizing:border-box;animation:rotation_spinner 1s linear infinite}@keyframes rotation_spinner{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduSpinner, decorators: [{
+            type: Component,
+            args: [{ selector: 'zen-spinner', template: "<div class=\"component\">\n</div>\n", styles: [".component{width:64px;height:64px;border:6px solid var(--color-primary, #2188d9);border-bottom-color:transparent;border-radius:50%;display:inline-block;box-sizing:border-box;animation:rotation_spinner 1s linear infinite}@keyframes rotation_spinner{0%{transform:rotate(0)}to{transform:rotate(360deg)}}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemVuZHUtc3Bpbm5lci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy16ZW5kdWl0L3NyYy9saWIvc3Bpbm5lci96ZW5kdS1zcGlubmVyLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXplbmR1aXQvc3JjL2xpYi9zcGlubmVyL3plbmR1LXNwaW5uZXIuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBUyxNQUFNLGVBQWUsQ0FBQzs7QUFPakQsTUFBTSxPQUFPLFlBQVk7OzBHQUFaLFlBQVk7OEZBQVosWUFBWSxtRENQekIscUNBRUE7NEZES2EsWUFBWTtrQkFMeEIsU0FBUzsrQkFDSSxhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ3plbi1zcGlubmVyJyxcbiAgICB0ZW1wbGF0ZVVybDogJy4vemVuZHUtc3Bpbm5lci5jb21wb25lbnQuaHRtbCcsXG4gICAgc3R5bGVVcmxzOiBbJy4vemVuZHUtc3Bpbm5lci5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIFplbmR1U3Bpbm5lciB7XG5cbn1cbiIsIjxkaXYgY2xhc3M9XCJjb21wb25lbnRcIj5cbjwvZGl2PlxuIl19

package/esm2020/lib/toggle/zendu-toggle.component.mjs

@@ -0,0 +1,32 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ZenduToggleComponent {
+    constructor() {
+        this.enabledChange = new EventEmitter();
+        this.onLabel = "On";
+        this.offLabel = "Off";
+    }
+    /**
+     * Toggle state
+     */
+    toggle() {
+        this.enabled = !this.enabled;
+        this.enabledChange.emit(this.enabled);
+    }
+}
+ZenduToggleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduToggleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ZenduToggleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: ZenduToggleComponent, selector: "zen-toggle", inputs: { enabled: "enabled", onLabel: "onLabel", offLabel: "offLabel" }, outputs: { enabledChange: "enabledChange" }, ngImport: i0, template: "<div class=\"toggle-component\">\n   <div class=\"toggle-component-content\"\n        (click)=\"toggle()\">\n      <div class=\"toggle-state toggle-state-left\"\n           [ngClass]=\"enabled ? 'toggle-active' : ''\">\n         {{onLabel}}\n      </div>\n      <div class=\"toggle-state toggle-state-right\"\n           [ngClass]=\"enabled ? '' : 'toggle-active'\">\n         {{offLabel}}\n      </div>\n   </div>\n</div>", styles: [".toggle-component{display:inline-block}.toggle-component .toggle-component-content{display:flex;flex-direction:row;align-items:center;justify-content:stretch;color:var(--color-grey-shade-2, #828282);cursor:pointer}.toggle-component .toggle-state{border:1px solid var(--color-grey-shade-2, #828282);padding:10px 16px;min-width:70px;text-align:center}.toggle-component .toggle-state-left{border-radius:4px 0 0 4px;border-right:1px solid var(--color-primary, #2188d9)}.toggle-component .toggle-state-right{border-radius:0 4px 4px 0;border-left:none}.toggle-component .toggle-active{background-color:var(--color-blue-tint-1, #f4f9fd);color:var(--color-primary, #2188d9);border-color:var(--color-primary, #2188d9)}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ZenduToggleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'zen-toggle', template: "<div class=\"toggle-component\">\n   <div class=\"toggle-component-content\"\n        (click)=\"toggle()\">\n      <div class=\"toggle-state toggle-state-left\"\n           [ngClass]=\"enabled ? 'toggle-active' : ''\">\n         {{onLabel}}\n      </div>\n      <div class=\"toggle-state toggle-state-right\"\n           [ngClass]=\"enabled ? '' : 'toggle-active'\">\n         {{offLabel}}\n      </div>\n   </div>\n</div>", styles: [".toggle-component{display:inline-block}.toggle-component .toggle-component-content{display:flex;flex-direction:row;align-items:center;justify-content:stretch;color:var(--color-grey-shade-2, #828282);cursor:pointer}.toggle-component .toggle-state{border:1px solid var(--color-grey-shade-2, #828282);padding:10px 16px;min-width:70px;text-align:center}.toggle-component .toggle-state-left{border-radius:4px 0 0 4px;border-right:1px solid var(--color-primary, #2188d9)}.toggle-component .toggle-state-right{border-radius:0 4px 4px 0;border-left:none}.toggle-component .toggle-active{background-color:var(--color-blue-tint-1, #f4f9fd);color:var(--color-primary, #2188d9);border-color:var(--color-primary, #2188d9)}\n"] }]
+        }], propDecorators: { enabled: [{
+                type: Input
+            }], enabledChange: [{
+                type: Output
+            }], onLabel: [{
+                type: Input
+            }], offLabel: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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