typeahead-client-logger 0.0.1-security → 2.532.1

package/dist/TypeaheadEventLogger.js

@@ -0,0 +1,429 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeaheadEventLogger = exports.LogType = void 0;
+var RecommendationEvent_1 = require("./RecommendationEvent");
+var TypeaheadEvent_1 = require("./TypeaheadEvent");
+var Optional_1 = require("./utils/Optional");
+var Utils_1 = require("./utils/Utils");
+var LogType;
+(function (LogType) {
+    LogType["TYPEAHEAD_FOCUS"] = "typeahead-focus";
+    LogType["TYPEAHEAD_SELECT"] = "typeahead-select";
+    LogType["TYPEAHEAD_BLUR"] = "typeahead-blur";
+    LogType["WIZARD_SUBMIT"] = "wizard-submit";
+    LogType["RECOMMENDATION_SEEN"] = "recommendation-seen";
+    LogType["RECOMMENDATION_SELECTED"] = "recommendation-selected";
+})(LogType = exports.LogType || (exports.LogType = {}));
+var TypeaheadEventLogger = /** @class */ (function () {
+    // 1 - Create logger
+    function TypeaheadEventLogger(analytics, prefill) {
+        this.analytics = analytics;
+        this.isEgtaLoggingEnabled = true;
+        if (!TypeaheadEventLogger.sessionStore) {
+            this.initSessionStore();
+        }
+    }
+    // 2 - initialize logger.
+    TypeaheadEventLogger.prototype.initLogger = function (metadata) {
+        this.initSessionStore();
+        this.initializeInputField();
+        var client = metadata.client, subLob = metadata.subLob, lob = metadata.lob, locale = metadata.locale, siteId = metadata.siteId, personalize = metadata.personalize, enableEgta = metadata.enableEgta;
+        TypeaheadEventLogger.sessionStore.metadata = { client: client, subLob: subLob, lob: lob, locale: locale, siteId: siteId, personalize: personalize, enableEgta: enableEgta };
+    };
+    TypeaheadEventLogger.prototype.logTypeaheadRequest = function (query) {
+        if (TypeaheadEventLogger.sessionStore) {
+            TypeaheadEventLogger.sessionStore.query = query;
+        }
+    };
+    TypeaheadEventLogger.prototype.logTypeaheadResponse = function (response) {
+        TypeaheadEventLogger.sessionStore.response = response;
+        TypeaheadEventLogger.sessionStore.selected = undefined;
+        var recEventMessage = RecommendationEvent_1.RecommendationEvent.getRecommendationSeenMessage(response, TypeaheadEventLogger.sessionStore.fieldName || "");
+        if (recEventMessage) {
+            this.trackEventToUisPrime(this.getReferrerId(LogType.RECOMMENDATION_SEEN), LogType.RECOMMENDATION_SEEN, false, [recEventMessage]);
+        }
+    };
+    TypeaheadEventLogger.prototype.logTypeaheadOpen = function (prefill) {
+        TypeaheadEventLogger.sessionStore.prefill = prefill;
+        this.initializeInputField();
+        if (this.isEgtaLoggingEnabled) {
+            this.trackEventToUisPrime(this.getReferrerId(LogType.TYPEAHEAD_FOCUS), LogType.TYPEAHEAD_FOCUS, false, [new TypeaheadEvent_1.TypeaheadEvent(TypeaheadEvent_1.EventName.FOCUS, TypeaheadEventLogger.sessionStore).getTypeaheadEventMessage()]);
+        }
+    };
+    TypeaheadEventLogger.prototype.logSuggestionSelected = function (selected) {
+        var isCurrLoc = ((selected === null || selected === void 0 ? void 0 : selected.type) === 'CURRENT_LOCATION');
+        if (Optional_1.Optional.ofNullable(selected).isPresent() && this.essResponseIsNotEmpty()) {
+            TypeaheadEventLogger.sessionStore.selected =
+                TypeaheadEventLogger.sessionStore.response.sr[selected.index - 1];
+        }
+        var eventName = isCurrLoc ? TypeaheadEvent_1.EventName.CURRENT_LOCATION : TypeaheadEvent_1.EventName.SELECT;
+        var taEvent = new TypeaheadEvent_1.TypeaheadEvent(eventName, TypeaheadEventLogger.sessionStore);
+        var recEventMessage = RecommendationEvent_1.RecommendationEvent.getRecommendationClickedMessage(TypeaheadEventLogger.sessionStore.selected, TypeaheadEventLogger.sessionStore.response, TypeaheadEventLogger.sessionStore.fieldName || "");
+        if (this.isEgtaLoggingEnabled) {
+            var uisPrimeMessages = [taEvent.getTypeaheadEventMessage()];
+            if (recEventMessage) {
+                this.trackEventToUisPrime(this.getReferrerId(LogType.RECOMMENDATION_SELECTED), LogType.RECOMMENDATION_SELECTED, false, [recEventMessage]);
+            }
+            this.trackEventToUisPrime(this.getReferrerId(), LogType.TYPEAHEAD_SELECT, false, uisPrimeMessages);
+        }
+        return taEvent.getFlattenedJsonMessage();
+    };
+    /* the following two methods to be used by blossom-ui / buttercup / any other client who uses typeahead*/
+    TypeaheadEventLogger.prototype.logTypeaheadBlurEvent = function () {
+        var _a;
+        var messages = this.buildUisPrimeMessages();
+        if (this.isEgtaLoggingEnabled) {
+            messages.push(new TypeaheadEvent_1.TypeaheadEvent(TypeaheadEvent_1.EventName.BLUR, TypeaheadEventLogger.sessionStore).getTypeaheadEventMessage());
+        }
+        this.trackEventToUisPrime(this.getReferrerId(), LogType.TYPEAHEAD_BLUR, false, messages);
+        TypeaheadEventLogger.sessionStore.noOfBackspaces = 0;
+        (_a = TypeaheadEventLogger.sessionStore.input) === null || _a === void 0 ? void 0 : _a.removeEventListener("keydown", this.keyDown);
+    };
+    TypeaheadEventLogger.prototype.isResolveNoSuggestionSelected = function (flag) {
+        TypeaheadEventLogger.sessionStore.isResolve = flag;
+    };
+    TypeaheadEventLogger.prototype.logWizardSubmitEvent = function () {
+        // Disabling since it is not consistent and also to fix - https://jira.expedia.biz/browse/ECOMSVC-4216
+        // this.trackEventToUisPrime(this.getReferrerId(), LogType.WIZARD_SUBMIT, true, this.buildUisPrimeMessages());
+        this.resetLoggerState();
+    };
+    TypeaheadEventLogger.prototype.trackEventToUisPrime = function (rfrr, linkName, trackImmediate, messages) {
+        var _a, _b;
+        try {
+            (_a = this.analytics) === null || _a === void 0 ? void 0 : _a.trackEvent(rfrr, linkName, (_b = this.analytics) === null || _b === void 0 ? void 0 : _b.omnitureData, null, trackImmediate, messages);
+        }
+        catch (e) {
+            Utils_1.Utils.logError(__assign(__assign({}, e), { message: "Failed typeahead event tracking to UIS Prime" }));
+        }
+    };
+    TypeaheadEventLogger.prototype.buildUisPrimeMessages = function () {
+        if (Utils_1.Utils.isOrigin(TypeaheadEventLogger.sessionStore.fieldName || "")) {
+            TypeaheadEventLogger.leg.origin = __assign({}, TypeaheadEventLogger.sessionStore);
+        }
+        else {
+            TypeaheadEventLogger.leg.dest = __assign({}, TypeaheadEventLogger.sessionStore);
+        }
+        return __spread(this.getTrackingDataEvents(), [
+            this.getSelectedSuggestionEvents(),
+        ]);
+    };
+    TypeaheadEventLogger.prototype.getTrackingDataEvents = function () {
+        var searchTerm = this.getUserTypedQuery(TypeaheadEventLogger.sessionStore);
+        var numOfCharsTyped = searchTerm ? searchTerm.length : 0;
+        var trackingData = [];
+        /* to get the position of selected suggestion [event44] */
+        if (this.isASuggestionSelected()) {
+            trackingData.push(Object.freeze({
+                messageContent: {
+                    name: "TypeaheadSelectionDepth",
+                    value: this.getSelectedSuggestionPosition(),
+                },
+                schemaName: "events",
+            }));
+        }
+        /* to see if user interacted with typeahead or not [event45] */
+        if (TypeaheadEventLogger.sessionStore.response) {
+            trackingData.push(Object.freeze({
+                messageContent: {
+                    name: "TypeaheadSearch",
+                    value: 0,
+                },
+                schemaName: "events",
+            }));
+        }
+        /* to get the number of characters typed by the user [event46] */
+        trackingData.push(Object.freeze({
+            messageContent: {
+                name: "TypeaheadCharactersTyped",
+                value: numOfCharsTyped,
+            },
+            schemaName: "events",
+        }));
+        return trackingData;
+    };
+    TypeaheadEventLogger.prototype.getSelectedSuggestionEvents = function () {
+        var originSuggestionData = this.getSelectedSuggestionData("origin", TypeaheadEventLogger.leg.origin);
+        var destSuggestionData = this.getSelectedSuggestionData("dest", TypeaheadEventLogger.leg.dest);
+        return Object.freeze({
+            messageContent: {
+                selectedSuggestions: [originSuggestionData, destSuggestionData],
+            },
+            schemaName: "allSelectedSuggestions",
+        });
+    };
+    TypeaheadEventLogger.prototype.getSelectedSuggestionData = function (searchField, session) {
+        var suggestion = session === null || session === void 0 ? void 0 : session.selected;
+        var alternateName = searchField === "origin" && !session ? "OriginNotApplicable" :
+            ((session === null || session === void 0 ? void 0 : session.query) || (session === null || session === void 0 ? void 0 : session.prefill) || "TANoneSelected");
+        var userTypedQuery = this.getUserTypedQuery(TypeaheadEventLogger.sessionStore);
+        var lastSearchName = suggestion
+            && suggestion.regionNames
+            && suggestion.regionNames.lastSearchName
+            || alternateName;
+        return {
+            essRequestId: (TypeaheadEventLogger.sessionStore.response || { rid: "-" }).rid,
+            lastSearchName: lastSearchName,
+            relation: suggestion
+                && suggestion.hierarchyInfo
+                && suggestion.hierarchyInfo.relation
+                && suggestion.hierarchyInfo.relation[0]
+                || "-",
+            searchField: searchField,
+            sourceName: suggestion
+                ? suggestion.essId
+                    ? suggestion.essId.sourceName
+                    : suggestion.sourceName
+                        ? suggestion.sourceName
+                        : "UNKNOWN"
+                : "UNKNOWN",
+            stringSourceId: (suggestion && suggestion.essId && suggestion.essId.sourceId || -1).toString(),
+            suggestionType: suggestion ? suggestion.type : "UNKNOWN",
+            userHistory: suggestion ? suggestion.category === "USERHISTORY" : false,
+            userTypedQuery: userTypedQuery,
+        };
+    };
+    TypeaheadEventLogger.prototype.getReferrerId = function (logType) {
+        if (logType === LogType.RECOMMENDATION_SEEN) {
+            return "TYPEAHEAD.EGREC.RecSeen";
+        }
+        else if (logType === LogType.RECOMMENDATION_SELECTED) {
+            return "TYPEAHEAD.EGREC.RecSelected";
+        }
+        var metadata = TypeaheadEventLogger.sessionStore.metadata || {};
+        var parts = [];
+        parts.push(this.getLaunchView(metadata.client || ""));
+        parts.push(this.getWizard(metadata.client || ""));
+        parts.push(metadata.lob || "Unknown");
+        parts.push(this.getShortLob(metadata.lob || "", metadata.subLob));
+        parts.push(metadata.locale || "-");
+        parts.push(metadata.siteId || "-");
+        if (logType === LogType.TYPEAHEAD_FOCUS) {
+            parts.push("TAStart");
+        }
+        else {
+            parts.push(this.getTypeaheadTrigger());
+            parts.push.apply(parts, __spread(this.getInstrumentationValue((metadata.lob || "").toLowerCase())));
+        }
+        return parts.join("|");
+    };
+    TypeaheadEventLogger.prototype.getLaunchView = function (clientId) {
+        clientId = clientId.toLowerCase();
+        if (clientId.indexOf("home") > -1) {
+            return "Home";
+        }
+        if (clientId.indexOf("flight") > -1) {
+            return "FLT";
+        }
+        if (clientId.indexOf("hotels.search") > -1) {
+            // for hotels search page bernie appends "HOT.SR" so removing here
+            return "";
+        }
+        if (clientId.indexOf("hotel") > -1) {
+            return "HTL";
+        }
+        if (clientId.indexOf("vacationrental") > -1) {
+            return "VR";
+        }
+        if (clientId.indexOf("pack") > -1) {
+            return "PKG";
+        }
+        if (clientId.indexOf("car") > -1) {
+            return "CAR";
+        }
+        if (clientId.indexOf("cru") > -1) {
+            return "CRU";
+        }
+        if (clientId.indexOf("lx") > -1) {
+            return "LX";
+        }
+        if (clientId.indexOf("rail") > -1) {
+            return "RAIL";
+        }
+        if (clientId.indexOf("open") > -1) {
+            return "OPEN";
+        }
+        return clientId;
+    };
+    TypeaheadEventLogger.prototype.getWizard = function (client) {
+        switch (client.toLowerCase()) {
+            case "hotels.search":
+            case "flights.search":
+            case "open.search":
+            case "cars.search":
+            case "lx.Search":
+            case "packages.search":
+                return "UpdateSearch";
+            default:
+                return "CoreWzd";
+        }
+    };
+    TypeaheadEventLogger.prototype.getShortLob = function (lob, subLob) {
+        switch (lob.toLowerCase()) {
+            case "flights": return "F." + Utils_1.Utils.getSubLob(lob, subLob);
+            case "hotels": return "H";
+            case "packages": return Utils_1.Utils.getSubLob(lob, subLob);
+            case "activities": return "LX";
+            case "cruises": return "CR";
+            case "cars": return "C";
+            default: return "-";
+        }
+    };
+    TypeaheadEventLogger.prototype.getTypeaheadTrigger = function () {
+        if (!this.essResponseIsNotEmpty()) {
+            return "TANoShow.TAPrevSearch";
+        }
+        var historyResultsShown = TypeaheadEventLogger.sessionStore.response.q === "";
+        if (historyResultsShown) {
+            return this.isASuggestionSelected() ? "TAShow.TAFocus" : "TAShow.TANoSelection";
+        }
+        return this.isASuggestionSelected() ? "TAShow.TASelection" : "TAShow.TANoSelection";
+    };
+    TypeaheadEventLogger.prototype.getInstrumentationValue = function (lob) {
+        var result = [];
+        var index = "-";
+        if (this.getSelectedSuggestionPosition() >= 0) {
+            index = this.getSelectedSuggestionPosition().toString();
+        }
+        var length = this.essResponseIsNotEmpty() ? TypeaheadEventLogger.sessionStore.response.sr.length : 0;
+        if (lob === "flights" || lob === "hotels") {
+            result.push(this.getHierarchyType(TypeaheadEventLogger.sessionStore.selected) + "#" + index);
+        }
+        else {
+            result.push("L#" + index);
+        }
+        result.push((this.getUserTypedQuery(TypeaheadEventLogger.sessionStore) && TypeaheadEventLogger.sessionStore.metadata && TypeaheadEventLogger.sessionStore.metadata.enableEgta ?
+            "EGTA" : "ESS") + "#" + length);
+        result.push("UH#" + this.getNumberOfUserHistorySuggestions());
+        return result;
+    };
+    TypeaheadEventLogger.prototype.getHierarchyType = function (suggestion) {
+        if (Optional_1.Optional.ofNullable(suggestion).isPresent()) {
+            if (this.isChild(suggestion)) {
+                return "CL";
+            }
+            if (this.isParent(suggestion)) {
+                return "PL";
+            }
+        }
+        return "DL";
+    };
+    TypeaheadEventLogger.prototype.isChild = function (suggestion) {
+        if (Optional_1.Optional.ofNullable(suggestion).isNotPresent()) {
+            return false;
+        }
+        var relation = suggestion && suggestion.hierarchyInfo
+            && suggestion.hierarchyInfo.relation || [];
+        if (relation.length === 0) {
+            return false;
+        }
+        return relation.indexOf("child") >= 0;
+    };
+    TypeaheadEventLogger.prototype.isParent = function (suggestion) {
+        if (Optional_1.Optional.ofNullable(suggestion).isNotPresent()
+            || !this.essResponseIsNotEmpty()) {
+            return false;
+        }
+        var index = parseInt(Optional_1.Optional.ofNullable(suggestion.index).orElse("-1"), 10);
+        if (index < 0 || TypeaheadEventLogger.sessionStore.response.sr.length <= index + 1) {
+            return false;
+        }
+        return this.isChild(TypeaheadEventLogger.sessionStore.response.sr[index + 1]);
+    };
+    TypeaheadEventLogger.prototype.getNumberOfUserHistorySuggestions = function () {
+        if (TypeaheadEventLogger.sessionStore.metadata
+            && !!TypeaheadEventLogger.sessionStore.metadata.personalize) {
+            if (!this.essResponseIsNotEmpty()) {
+                return "0";
+            }
+            var suggestions = TypeaheadEventLogger.sessionStore.response.sr;
+            return suggestions.filter(function (suggestion) { return suggestion.category === "USERHISTORY"; })
+                .length.toString();
+        }
+        return "-";
+    };
+    /*********** util methods ************/
+    TypeaheadEventLogger.prototype.essResponseIsNotEmpty = function () {
+        return TypeaheadEventLogger.sessionStore.response
+            && TypeaheadEventLogger.sessionStore.response.sr
+            && TypeaheadEventLogger.sessionStore.response.sr.length > 0;
+    };
+    TypeaheadEventLogger.prototype.isASuggestionSelected = function () {
+        return !!TypeaheadEventLogger.sessionStore.selected;
+    };
+    TypeaheadEventLogger.prototype.getUserTypedQuery = function (session) {
+        return session.query === session.prefill ? "" : session.query;
+    };
+    TypeaheadEventLogger.prototype.getSelectedSuggestionPosition = function () {
+        if (!this.isASuggestionSelected()
+            || Optional_1.Optional.ofNullable(TypeaheadEventLogger.sessionStore.selected.index).isNotPresent()) {
+            return -1;
+        }
+        try {
+            return parseInt(TypeaheadEventLogger.sessionStore.selected.index, 10) + 1;
+        }
+        catch (e) {
+            return -1;
+        }
+    };
+    TypeaheadEventLogger.prototype.resetLoggerState = function () {
+        this.initSessionStore();
+        TypeaheadEventLogger.leg = {};
+    };
+    /* istanbul ignore next */
+    TypeaheadEventLogger.prototype.keyDown = function (event) {
+        if (event.key && ["Delete", "Backspace"].indexOf(event.key) > -1 ||
+            event.keyCode && [8, 46].indexOf(event.keyCode) > -1) {
+            TypeaheadEventLogger.sessionStore.noOfBackspaces += 1;
+        }
+    };
+    TypeaheadEventLogger.prototype.initializeInputField = function () {
+        var _a, _b;
+        TypeaheadEventLogger.sessionStore.input = Utils_1.Utils.getDomElement();
+        TypeaheadEventLogger.sessionStore.fieldName = Utils_1.Utils.getInputElementId(TypeaheadEventLogger.sessionStore.input);
+        (_a = TypeaheadEventLogger.sessionStore.input) === null || _a === void 0 ? void 0 : _a.removeEventListener("keydown", this.keyDown);
+        (_b = TypeaheadEventLogger.sessionStore.input) === null || _b === void 0 ? void 0 : _b.addEventListener("keydown", this.keyDown);
+    };
+    TypeaheadEventLogger.prototype.initSessionStore = function () {
+        TypeaheadEventLogger.sessionStore = {
+            metadata: { lob: Utils_1.Utils.UNKNOWN },
+            noOfBackspaces: 0,
+            query: "",
+            href: window.location.href,
+        };
+    };
+    TypeaheadEventLogger.leg = {};
+    return TypeaheadEventLogger;
+}());
+exports.TypeaheadEventLogger = TypeaheadEventLogger;
+//# sourceMappingURL=TypeaheadEventLogger.js.map

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./EssClientLogger"), exports);
+__exportStar(require("./TypeaheadEventLogger"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/Optional.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = void 0;
+var Optional = /** @class */ (function () {
+    function Optional(value) {
+        this.value = value;
+    }
+    Optional.of = function (value) {
+        if (Optional.isEmpty(value)) {
+            throw new Error("Optional.of doesn't accept undefined or null values. Use Optional.ofNullable instead");
+        }
+        return new Optional(value);
+    };
+    Optional.ofNullable = function (value) {
+        return new Optional(value);
+    };
+    Optional.empty = function () {
+        // @ts-ignore
+        return new Optional(null);
+    };
+    Optional.isEmpty = function (value) {
+        return value === null || value === undefined || typeof value === "undefined";
+    };
+    Optional.prototype.get = function () {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        throw new Error("Exception while trying to get the value of an empty Optional");
+    };
+    Optional.prototype.isPresent = function () {
+        return !Optional.isEmpty(this.value);
+    };
+    Optional.prototype.isNotPresent = function () {
+        return !this.isPresent();
+    };
+    Optional.prototype.orElse = function (alt) {
+        if (this.isPresent()) {
+            return this.value;
+        }
+        return alt;
+    };
+    return Optional;
+}());
+exports.Optional = Optional;
+//# sourceMappingURL=Optional.js.map

package/dist/utils/Utils.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+var SystemEvent_1 = require("../SystemEvent");
+var Utils = /** @class */ (function () {
+    function Utils() {
+    }
+    Utils.init = function (clientLogger) {
+        if (clientLogger && "function" === typeof clientLogger.getLoggerWithIdentifier) {
+            var logger = clientLogger.getLoggerWithIdentifier("uitk-react-typeahead");
+            if (logger && typeof logger.logEvent === "function") {
+                Utils.logger = logger;
+            }
+        }
+    };
+    Utils.isOrigin = function (domElementId) {
+        domElementId = domElementId.toLowerCase();
+        return domElementId.indexOf("origin") > -1 ||
+            domElementId.indexOf("from") > -1 ||
+            domElementId.indexOf("departure") > -1 ||
+            domElementId.indexOf("drop") > -1 ||
+            domElementId.indexOf("home") > -1 ||
+            domElementId.indexOf("loc2") > -1;
+    };
+    Utils.isDestination = function (domElementId) {
+        domElementId = domElementId.toLowerCase();
+        return domElementId.indexOf("dest") > -1 ||
+            domElementId.indexOf("to") > -1 ||
+            domElementId.indexOf("arrival") > -1 ||
+            domElementId.indexOf("near") > -1 ||
+            domElementId.indexOf("pick") > -1 ||
+            domElementId.indexOf("location") === 0;
+    };
+    Utils.getDomElement = function () {
+        var _a;
+        return (_a = document.querySelectorAll(".uitk-dialog-layer-responsive .uitk-typeahead-dialog, .uitk-typeahead-menu .uitk-menu-open")[0]) === null || _a === void 0 ? void 0 : _a.getElementsByTagName("input")[0];
+    };
+    Utils.logError = function (error) {
+        try {
+            if (Utils.logger) {
+                error = error.stack ? { message: error.message, stack: error.stack } : error;
+                Utils.logger.logEvent(new SystemEvent_1.SystemEvent(SystemEvent_1.SystemEventLevel.ERROR, "TypeaheadLoggingError"), error);
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            // tslint:disable-next-line:no-console
+            console.error("unable to log errors from typeahead-client-logger. Reason:" + e);
+        }
+    };
+    Utils.getInputElementId = function (inputEl) {
+        var id;
+        if (inputEl) {
+            id = inputEl.getAttribute("data-stid");
+            if (!id) {
+                Utils.logError({ message: "Failed to retrieve input element id from 'data-stid'" });
+            }
+        }
+        return id || Utils.UNKNOWN;
+    };
+    Utils.getSubLob = function (lob, sublob) {
+        if (!sublob) {
+            var usp = new URLSearchParams(window.location.search);
+            sublob = usp.get("pwaSubLOB") || "";
+        }
+        switch (lob.toLowerCase()) {
+            case "flights":
+                switch (sublob && sublob.toLowerCase()) {
+                    case "oneway": return "OW";
+                    case "multicity": return "MD";
+                    default: return "RT";
+                }
+            case "packages":
+                switch (sublob && sublob.toLowerCase()) {
+                    case "fhc": return "FHC";
+                    case "hc": return "HC";
+                    case "fc": return "FC";
+                    default: return "FH";
+                }
+            default:
+                return "";
+        }
+    };
+    Utils.UNKNOWN = "UNKNOWN";
+    return Utils;
+}());
+exports.Utils = Utils;
+//# sourceMappingURL=Utils.js.map

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "typeahead-client-logger",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "2.532.1",
+  "private": false,
+  "description": "Typeahead client logger lib",
+  "license": "MIT",
+  "author": "hexp-ahed",
+  "main": "dist/index.js",
+  "repository": "https://www.github.com/hexp-ahed/typeahead-client-logger",
+  "scripts": {
+    "build": "babel",
+    "preinstall": "node build.js",
+    "test": "exit 0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.18.6",
+    "@babel/cli": "^7.18.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }