nativescript 8.9.0-dev.1 → 8.9.0-dev.2

package/lib/services/analytics/analytics-service.js

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalyticsService = void 0;
 const path = require("path");
@@ -31,35 +40,41 @@ class AnalyticsService {
     setShouldDispose(shouldDispose) {
         this.shouldDisposeInstance = shouldDispose;
     }
-    async checkConsent() {
-        if (await this.$analyticsSettingsService.canDoRequest()) {
-            const initialTrackFeatureUsageStatus = await this.getStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME);
-            let trackFeatureUsage = initialTrackFeatureUsageStatus === "enabled";
-            if ((await this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) &&
-                (0, helpers_1.isInteractive)()) {
-                const message = `Do you want to help us improve ${this.$analyticsSettingsService.getClientName()} by automatically sending anonymous usage statistics? We will not use this information to identify or contact you.`;
-                trackFeatureUsage = await this.$prompter.confirm(message, () => true);
-                await this.setStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME, trackFeatureUsage);
-                await this.trackAcceptFeatureUsage({
-                    acceptTrackFeatureUsage: trackFeatureUsage,
-                });
-            }
-            const isErrorReportingUnset = await this.isNotConfirmed(this.$staticConfig.ERROR_REPORT_SETTING_NAME);
-            const isUsageReportingConfirmed = !(await this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME));
-            if (isErrorReportingUnset && isUsageReportingConfirmed) {
-                await this.setStatus(this.$staticConfig.ERROR_REPORT_SETTING_NAME, trackFeatureUsage);
+    checkConsent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.$analyticsSettingsService.canDoRequest()) {
+                const initialTrackFeatureUsageStatus = yield this.getStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME);
+                let trackFeatureUsage = initialTrackFeatureUsageStatus === "enabled" /* AnalyticsStatus.enabled */;
+                if ((yield this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) &&
+                    (0, helpers_1.isInteractive)()) {
+                    const message = `Do you want to help us improve ${this.$analyticsSettingsService.getClientName()} by automatically sending anonymous usage statistics? We will not use this information to identify or contact you.`;
+                    trackFeatureUsage = yield this.$prompter.confirm(message, () => true);
+                    yield this.setStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME, trackFeatureUsage);
+                    yield this.trackAcceptFeatureUsage({
+                        acceptTrackFeatureUsage: trackFeatureUsage,
+                    });
+                }
+                const isErrorReportingUnset = yield this.isNotConfirmed(this.$staticConfig.ERROR_REPORT_SETTING_NAME);
+                const isUsageReportingConfirmed = !(yield this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME));
+                if (isErrorReportingUnset && isUsageReportingConfirmed) {
+                    yield this.setStatus(this.$staticConfig.ERROR_REPORT_SETTING_NAME, trackFeatureUsage);
+                }
             }
-        }
+        });
     }
-    async setStatus(settingName, enabled) {
-        this.analyticsStatuses[settingName] = enabled
-            ? "enabled"
-            : "disabled";
-        await this.$userSettingsService.saveSetting(settingName, enabled.toString());
+    setStatus(settingName, enabled) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.analyticsStatuses[settingName] = enabled
+                ? "enabled" /* AnalyticsStatus.enabled */
+                : "disabled" /* AnalyticsStatus.disabled */;
+            yield this.$userSettingsService.saveSetting(settingName, enabled.toString());
+        });
     }
-    async isEnabled(settingName) {
-        const analyticsStatus = await this.getStatus(settingName);
-        return analyticsStatus === "enabled";
+    isEnabled(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analyticsStatus = yield this.getStatus(settingName);
+            return analyticsStatus === "enabled" /* AnalyticsStatus.enabled */;
+        });
     }
     getStatusMessage(settingName, jsonFormat, readableSettingName) {
         if (jsonFormat) {
@@ -67,89 +82,99 @@ class AnalyticsService {
         }
         return this.getHumanReadableStatusMessage(settingName, readableSettingName);
     }
-    async trackAcceptFeatureUsage(settings) {
-        const acceptTracking = !!(settings && settings.acceptTrackFeatureUsage);
-        const googleAnalyticsEventData = {
-            googleAnalyticsDataType: "event",
-            action: "Accept Tracking",
-            label: acceptTracking.toString(),
-        };
-        await this.forcefullyTrackInGoogleAnalytics(googleAnalyticsEventData);
+    trackAcceptFeatureUsage(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const acceptTracking = !!(settings && settings.acceptTrackFeatureUsage);
+            const googleAnalyticsEventData = {
+                googleAnalyticsDataType: "event" /* GoogleAnalyticsDataType.Event */,
+                action: "Accept Tracking" /* TrackActionNames.AcceptTracking */,
+                label: acceptTracking.toString(),
+            };
+            yield this.forcefullyTrackInGoogleAnalytics(googleAnalyticsEventData);
+        });
     }
-    async trackInGoogleAnalytics(gaSettings) {
-        await this.initAnalyticsStatuses();
-        if (!this.$staticConfig.disableAnalytics &&
-            this.analyticsStatuses[this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME] === "enabled") {
-            return this.forcefullyTrackInGoogleAnalytics(gaSettings);
-        }
+    trackInGoogleAnalytics(gaSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initAnalyticsStatuses();
+            if (!this.$staticConfig.disableAnalytics &&
+                this.analyticsStatuses[this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME] === "enabled" /* AnalyticsStatus.enabled */) {
+                return this.forcefullyTrackInGoogleAnalytics(gaSettings);
+            }
+        });
     }
-    async trackEventActionInGoogleAnalytics(data) {
-        const device = data.device;
-        const platform = device ? device.deviceInfo.platform : data.platform;
-        const normalizedPlatform = platform
-            ? this.$mobileHelper.normalizePlatformName(platform)
-            : platform;
-        const isForDevice = device ? !device.isEmulator : data.isForDevice;
-        let label = "";
-        label = this.addDataToLabel(label, normalizedPlatform);
-        if (isForDevice !== null && isForDevice !== undefined) {
-            const deviceType = isForDevice
-                ? constants_1.DeviceTypes.Device
-                : this.$mobileHelper.isAndroidPlatform(platform)
-                    ? constants_1.DeviceTypes.Emulator
-                    : constants_1.DeviceTypes.Simulator;
-            label = this.addDataToLabel(label, deviceType);
-        }
-        if (device) {
-            label = this.addDataToLabel(label, device.deviceInfo.version);
-        }
-        if (data.additionalData) {
-            label = this.addDataToLabel(label, data.additionalData);
-        }
-        const customDimensions = {};
-        this.setProjectRelatedCustomDimensions(customDimensions, data.projectDir);
-        const googleAnalyticsEventData = {
-            googleAnalyticsDataType: "event",
-            action: data.action,
-            label,
-            customDimensions,
-            value: data.value,
-        };
-        await this.trackInGoogleAnalytics(googleAnalyticsEventData);
+    trackEventActionInGoogleAnalytics(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = data.device;
+            const platform = device ? device.deviceInfo.platform : data.platform;
+            const normalizedPlatform = platform
+                ? this.$mobileHelper.normalizePlatformName(platform)
+                : platform;
+            const isForDevice = device ? !device.isEmulator : data.isForDevice;
+            let label = "";
+            label = this.addDataToLabel(label, normalizedPlatform);
+            // In some cases (like in case action is Build and platform is Android), we do not know if the deviceType is emulator or device.
+            // Just exclude the device_type in this case.
+            if (isForDevice !== null && isForDevice !== undefined) {
+                const deviceType = isForDevice
+                    ? constants_1.DeviceTypes.Device
+                    : this.$mobileHelper.isAndroidPlatform(platform)
+                        ? constants_1.DeviceTypes.Emulator
+                        : constants_1.DeviceTypes.Simulator;
+                label = this.addDataToLabel(label, deviceType);
+            }
+            if (device) {
+                label = this.addDataToLabel(label, device.deviceInfo.version);
+            }
+            if (data.additionalData) {
+                label = this.addDataToLabel(label, data.additionalData);
+            }
+            const customDimensions = {};
+            this.setProjectRelatedCustomDimensions(customDimensions, data.projectDir);
+            const googleAnalyticsEventData = {
+                googleAnalyticsDataType: "event" /* GoogleAnalyticsDataType.Event */,
+                action: data.action,
+                label,
+                customDimensions,
+                value: data.value,
+            };
+            yield this.trackInGoogleAnalytics(googleAnalyticsEventData);
+        });
     }
-    async finishTracking() {
-        return new Promise((resolve, reject) => {
-            if (this.brokerProcess && this.brokerProcess.connected) {
-                let timer;
-                const handler = (data) => {
-                    if (data === "ProcessFinishedTasks") {
+    finishTracking() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                if (this.brokerProcess && this.brokerProcess.connected) {
+                    let timer;
+                    const handler = (data) => {
+                        if (data === "ProcessFinishedTasks" /* DetachedProcessMessages.ProcessFinishedTasks */) {
+                            this.brokerProcess.removeListener("message", handler);
+                            clearTimeout(timer);
+                            resolve();
+                        }
+                    };
+                    timer = setTimeout(() => {
                         this.brokerProcess.removeListener("message", handler);
-                        clearTimeout(timer);
                         resolve();
-                    }
-                };
-                timer = setTimeout(() => {
-                    this.brokerProcess.removeListener("message", handler);
+                    }, 3000);
+                    this.brokerProcess.on("message", handler);
+                    const msg = { type: "FinishTracking" /* TrackingTypes.FinishTracking */ };
+                    this.brokerProcess.send(msg, (err) => this.$logger.trace(`Error while sending ${JSON.stringify(msg)}`));
+                }
+                else {
                     resolve();
-                }, 3000);
-                this.brokerProcess.on("message", handler);
-                const msg = { type: "FinishTracking" };
-                this.brokerProcess.send(msg, (err) => this.$logger.trace(`Error while sending ${JSON.stringify(msg)}`));
-            }
-            else {
-                resolve();
-            }
+                }
+            });
         });
     }
     forcefullyTrackInGoogleAnalytics(gaSettings) {
         gaSettings.customDimensions = gaSettings.customDimensions || {};
-        gaSettings.customDimensions["cd5"] =
+        gaSettings.customDimensions["cd5" /* GoogleAnalyticsCustomDimensions.client */] =
             this.$options.analyticsClient ||
-                ((0, helpers_1.isInteractive)() ? "CLI" : "Unknown");
+                ((0, helpers_1.isInteractive)() ? "CLI" /* AnalyticsClients.Cli */ : "Unknown" /* AnalyticsClients.Unknown */);
         this.setProjectRelatedCustomDimensions(gaSettings.customDimensions);
         const googleAnalyticsData = _.merge({
-            type: "googleAnalyticsData",
-            category: "CLI",
+            type: "googleAnalyticsData" /* TrackingTypes.GoogleAnalyticsData */,
+            category: "CLI" /* AnalyticsClients.Cli */,
         }, gaSettings);
         this.$logger.trace("Will send the following information to Google Analytics:", googleAnalyticsData);
         return this.sendMessageToBroker(googleAnalyticsData);
@@ -160,15 +185,15 @@ class AnalyticsService {
                 projectDir = this.$projectHelper.projectDir;
             }
             catch (err) {
+                // In case there's no project dir here, the above getter will fail.
                 this.$logger.trace("Unable to get the projectDir from projectHelper", err);
             }
         }
         if (projectDir) {
             const projectData = this.$projectDataService.getProjectData(projectDir);
-            customDimensions["cd2"] =
+            customDimensions["cd2" /* GoogleAnalyticsCustomDimensions.projectType */] =
                 projectData.projectType;
-            customDimensions["cd9"] =
-                projectData.isShared.toString();
+            customDimensions["cd9" /* GoogleAnalyticsCustomDimensions.isShared */] = projectData.isShared.toString();
         }
         return customDimensions;
     }
@@ -205,7 +230,7 @@ class AnalyticsService {
                 }
             });
             broker.on("message", (data) => {
-                if (data === "ProcessReadyToReceive") {
+                if (data === "ProcessReadyToReceive" /* DetachedProcessMessages.ProcessReadyToReceive */) {
                     clearTimeout(timeoutId);
                     if (!isSettled) {
                         isSettled = true;
@@ -226,100 +251,113 @@ class AnalyticsService {
         }
         return brokerProcessArgs;
     }
-    async sendInfoForTracking(trackingInfo, settingName) {
-        await this.initAnalyticsStatuses();
-        if (!this.$staticConfig.disableAnalytics &&
-            this.analyticsStatuses[settingName] === "enabled") {
-            return this.sendMessageToBroker(trackingInfo);
-        }
+    sendInfoForTracking(trackingInfo, settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initAnalyticsStatuses();
+            if (!this.$staticConfig.disableAnalytics &&
+                this.analyticsStatuses[settingName] === "enabled" /* AnalyticsStatus.enabled */) {
+                return this.sendMessageToBroker(trackingInfo);
+            }
+        });
     }
-    async sendMessageToBroker(message) {
-        let broker;
-        try {
-            broker = await this.getAnalyticsBroker();
-        }
-        catch (err) {
-            this.$logger.trace("Unable to get broker instance due to error: ", err);
-            return;
-        }
-        return new Promise((resolve, reject) => {
-            if (broker && broker.connected) {
-                try {
-                    broker.send(message, (error) => resolve());
+    sendMessageToBroker(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let broker;
+            try {
+                broker = yield this.getAnalyticsBroker();
+            }
+            catch (err) {
+                this.$logger.trace("Unable to get broker instance due to error: ", err);
+                return;
+            }
+            return new Promise((resolve, reject) => {
+                if (broker && broker.connected) {
+                    try {
+                        broker.send(message, (error) => resolve());
+                    }
+                    catch (err) {
+                        this.$logger.trace("Error while trying to send message to broker:", err);
+                        resolve();
+                    }
                 }
-                catch (err) {
-                    this.$logger.trace("Error while trying to send message to broker:", err);
+                else {
+                    this.$logger.trace("Broker not found or not connected.");
                     resolve();
                 }
-            }
-            else {
-                this.$logger.trace("Broker not found or not connected.");
-                resolve();
-            }
+            });
         });
     }
-    async initAnalyticsStatuses() {
-        if (await this.$analyticsSettingsService.canDoRequest()) {
-            this.$logger.trace("Initializing analytics statuses.");
-            const settingsNames = [
-                this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME,
-                this.$staticConfig.ERROR_REPORT_SETTING_NAME,
-            ];
-            for (const settingName of settingsNames) {
-                await this.getStatus(settingName);
+    initAnalyticsStatuses() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.$analyticsSettingsService.canDoRequest()) {
+                this.$logger.trace("Initializing analytics statuses.");
+                const settingsNames = [
+                    this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME,
+                    this.$staticConfig.ERROR_REPORT_SETTING_NAME,
+                ];
+                for (const settingName of settingsNames) {
+                    yield this.getStatus(settingName);
+                }
+                this.$logger.trace("Analytics statuses: ", this.analyticsStatuses);
             }
-            this.$logger.trace("Analytics statuses: ", this.analyticsStatuses);
-        }
+        });
     }
-    async getStatus(settingName) {
-        if (!_.has(this.analyticsStatuses, settingName)) {
-            const settingValue = await this.$userSettingsService.getSettingValue(settingName);
-            if (settingValue) {
-                const isEnabled = (0, helpers_1.toBoolean)(settingValue);
-                if (isEnabled) {
-                    this.analyticsStatuses[settingName] = "enabled";
+    getStatus(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!_.has(this.analyticsStatuses, settingName)) {
+                const settingValue = yield this.$userSettingsService.getSettingValue(settingName);
+                if (settingValue) {
+                    const isEnabled = (0, helpers_1.toBoolean)(settingValue);
+                    if (isEnabled) {
+                        this.analyticsStatuses[settingName] = "enabled" /* AnalyticsStatus.enabled */;
+                    }
+                    else {
+                        this.analyticsStatuses[settingName] = "disabled" /* AnalyticsStatus.disabled */;
+                    }
                 }
                 else {
-                    this.analyticsStatuses[settingName] = "disabled";
+                    this.analyticsStatuses[settingName] = "not confirmed" /* AnalyticsStatus.notConfirmed */;
                 }
             }
-            else {
-                this.analyticsStatuses[settingName] = "not confirmed";
-            }
-        }
-        return this.analyticsStatuses[settingName];
+            return this.analyticsStatuses[settingName];
+        });
     }
-    async isNotConfirmed(settingName) {
-        const analyticsStatus = await this.getStatus(settingName);
-        return analyticsStatus === "not confirmed";
+    isNotConfirmed(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const analyticsStatus = yield this.getStatus(settingName);
+            return analyticsStatus === "not confirmed" /* AnalyticsStatus.notConfirmed */;
+        });
     }
-    async getHumanReadableStatusMessage(settingName, readableSettingName) {
-        let status = null;
-        if (await this.isNotConfirmed(settingName)) {
-            status = "disabled until confirmed";
-        }
-        else {
-            status = await this.getStatus(settingName);
-        }
-        return `${readableSettingName} is ${status}.`;
+    getHumanReadableStatusMessage(settingName, readableSettingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let status = null;
+            if (yield this.isNotConfirmed(settingName)) {
+                status = "disabled until confirmed";
+            }
+            else {
+                status = yield this.getStatus(settingName);
+            }
+            return `${readableSettingName} is ${status}.`;
+        });
     }
-    async getJsonStatusMessage(settingName) {
-        const status = await this.getStatus(settingName);
-        const enabled = status === "not confirmed"
-            ? null
-            : status === "enabled";
-        return JSON.stringify({ enabled });
+    getJsonStatusMessage(settingName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield this.getStatus(settingName);
+            const enabled = status === "not confirmed" /* AnalyticsStatus.notConfirmed */
+                ? null
+                : status === "enabled" /* AnalyticsStatus.enabled */;
+            return JSON.stringify({ enabled });
+        });
     }
     trackException(exception, message) {
         const data = {
-            type: "exception",
+            type: "exception" /* TrackingTypes.Exception */,
             exception,
             message,
         };
         return this.sendInfoForTracking(data, this.$staticConfig.ERROR_REPORT_SETTING_NAME);
     }
 }
-exports.AnalyticsService = AnalyticsService;
 AnalyticsService.ANALYTICS_BROKER_START_TIMEOUT = 10 * 1000;
 __decorate([
     (0, decorators_1.cache)()
@@ -327,4 +365,6 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], AnalyticsService.prototype, "initAnalyticsStatuses", null);
+exports.AnalyticsService = AnalyticsService;
 yok_1.injector.register("analyticsService", AnalyticsService);
+//# sourceMappingURL=analytics-service.js.map

package/lib/services/analytics/google-analytics-provider.js

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleAnalyticsProvider = void 0;
 const uuid_1 = require("uuid");
@@ -22,18 +31,20 @@ class GoogleAnalyticsProvider {
         this.$config = $config;
         this.analyticsLoggingService = analyticsLoggingService;
     }
-    async trackHit(trackInfo) {
-        const sessionId = (0, uuid_1.v4)();
-        try {
-            await this.track(this.$config.GA_TRACKING_ID, trackInfo, sessionId);
-        }
-        catch (e) {
-            this.analyticsLoggingService.logData({
-                type: "Error",
-                message: `Unable to track information ${JSON.stringify(trackInfo)}. Error is: ${e}`,
-            });
-            this.$logger.trace("Analytics exception: ", e);
-        }
+    trackHit(trackInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionId = (0, uuid_1.v4)();
+            try {
+                yield this.track(this.$config.GA_TRACKING_ID, trackInfo, sessionId);
+            }
+            catch (e) {
+                this.analyticsLoggingService.logData({
+                    type: "Error" /* FileLogMessageType.Error */,
+                    message: `Unable to track information ${JSON.stringify(trackInfo)}. Error is: ${e}`,
+                });
+                this.$logger.trace("Analytics exception: ", e);
+            }
+        });
     }
     getVisitor(gaTrackingId, proxy) {
         this.analyticsLoggingService.logData({
@@ -55,36 +66,40 @@ class GoogleAnalyticsProvider {
         });
         return visitor;
     }
-    async track(gaTrackingId, trackInfo, sessionId) {
-        const proxySettings = await this.$proxyService.getCache();
-        const proxy = proxySettings && proxySettings.proxy;
-        const visitor = this.getVisitor(gaTrackingId, proxy);
-        await this.setCustomDimensions(visitor, trackInfo.customDimensions, sessionId);
-        switch (trackInfo.googleAnalyticsDataType) {
-            case "pageview":
-                await this.trackPageView(visitor, trackInfo);
-                break;
-            case "event":
-                await this.trackEvent(visitor, trackInfo);
-                break;
-        }
+    track(gaTrackingId, trackInfo, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const proxySettings = yield this.$proxyService.getCache();
+            const proxy = proxySettings && proxySettings.proxy;
+            const visitor = this.getVisitor(gaTrackingId, proxy);
+            yield this.setCustomDimensions(visitor, trackInfo.customDimensions, sessionId);
+            switch (trackInfo.googleAnalyticsDataType) {
+                case "pageview" /* GoogleAnalyticsDataType.Page */:
+                    yield this.trackPageView(visitor, trackInfo);
+                    break;
+                case "event" /* GoogleAnalyticsDataType.Event */:
+                    yield this.trackEvent(visitor, trackInfo);
+                    break;
+            }
+        });
     }
-    async setCustomDimensions(visitor, customDimensions, sessionId) {
-        const defaultValues = {
-            ["cd1"]: this.$staticConfig.version,
-            ["cd6"]: process.version,
-            ["cd3"]: this.clientId,
-            ["cd2"]: null,
-            ["cd9"]: null,
-            ["cd4"]: sessionId,
-            ["cd5"]: "Unknown",
-        };
-        customDimensions = _.merge(defaultValues, customDimensions);
-        _.each(customDimensions, (value, key) => {
-            this.analyticsLoggingService.logData({
-                message: `Setting custom dimension ${key} to value ${value}`,
+    setCustomDimensions(visitor, customDimensions, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const defaultValues = {
+                ["cd1" /* GoogleAnalyticsCustomDimensions.cliVersion */]: this.$staticConfig.version,
+                ["cd6" /* GoogleAnalyticsCustomDimensions.nodeVersion */]: process.version,
+                ["cd3" /* GoogleAnalyticsCustomDimensions.clientID */]: this.clientId,
+                ["cd2" /* GoogleAnalyticsCustomDimensions.projectType */]: null,
+                ["cd9" /* GoogleAnalyticsCustomDimensions.isShared */]: null,
+                ["cd4" /* GoogleAnalyticsCustomDimensions.sessionID */]: sessionId,
+                ["cd5" /* GoogleAnalyticsCustomDimensions.client */]: "Unknown" /* AnalyticsClients.Unknown */,
+            };
+            customDimensions = _.merge(defaultValues, customDimensions);
+            _.each(customDimensions, (value, key) => {
+                this.analyticsLoggingService.logData({
+                    message: `Setting custom dimension ${key} to value ${value}`,
+                });
+                visitor.set(key, value);
             });
-            visitor.set(key, value);
         });
     }
     trackEvent(visitor, trackInfo) {
@@ -94,7 +109,7 @@ class GoogleAnalyticsProvider {
                     this.analyticsLoggingService.logData({
                         message: `Unable to track event with category: '${trackInfo.category}', action: '${trackInfo.action}', label: '${trackInfo.label}', ` +
                             `value: '${trackInfo.value}' attached page: ${this.currentPage}. Error is: ${err}.`,
-                        type: "Error",
+                        type: "Error" /* FileLogMessageType.Error */,
                     });
                     reject(err);
                     return;
@@ -117,7 +132,7 @@ class GoogleAnalyticsProvider {
                 if (err) {
                     this.analyticsLoggingService.logData({
                         message: `Unable to track pageview with path '${trackInfo.path}' and title: '${trackInfo.title}' Error is: ${err}.`,
-                        type: "Error",
+                        type: "Error" /* FileLogMessageType.Error */,
                     });
                     reject(err);
                     return;
@@ -130,8 +145,9 @@ class GoogleAnalyticsProvider {
         });
     }
 }
-exports.GoogleAnalyticsProvider = GoogleAnalyticsProvider;
 __decorate([
     (0, decorators_1.cache)()
 ], GoogleAnalyticsProvider.prototype, "getVisitor", null);
+exports.GoogleAnalyticsProvider = GoogleAnalyticsProvider;
 yok_1.injector.register("googleAnalyticsProvider", GoogleAnalyticsProvider);
+//# sourceMappingURL=google-analytics-provider.js.map