atriusmaps-node-sdk 3.3.897 → 3.3.899

package/dist/cjs/plugins/poiDataManager/src/poiDataManager.js

@@ -26,13 +26,11 @@ function _interopNamespaceDefault(e) {
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
 async function create(app) {
-  const log = app.log.sublog('poiDataManager');
+  const log = app.log.sublog("poiDataManager");
   const init = () => {
-    app.bus.send('venueData/loadPoiData');
+    app.bus.send("venueData/loadPoiData");
   };
-
   let poisLoaded = new Zousan();
-
   const fixPositionInfo = (poi, structuresLookup) => {
     const { position } = poi;
     const structure = structuresLookup.floorIdToStructure(position.floorId);
@@ -46,98 +44,88 @@ async function create(app) {
       structureName: structure.name,
       buildingId: structure.id,
       floorName: floor.name,
-      floorOrdinal: floor.ordinal,
+      floorOrdinal: floor.ordinal
     };
     return { ...poi, position: detailedPosition };
   };
-
-  // todo R.map may be enough to update dictionary values
   const formatPois = (pois, structuresLookup) => {
     return R__namespace.pipe(
       R__namespace.values,
-      R__namespace.map(poi => {
+      R__namespace.map((poi) => {
         poi.distance = null;
-        poi.isNavigable = poi.isNavigable === undefined || poi.isNavigable === true; // isNavigable is true as default, and is optional in the POI data
-        // poi.isNavigable = /^[a-mA-M]+/.test(poi.name) // uncomment for easy testing of isNavigable
+        poi.staticName = poi.name;
+        poi.isNavigable = poi.isNavigable === void 0 || poi.isNavigable === true;
         if (poi.capacity) {
           addToRoomInfo(poi, {
-            name: `Seats ${poi.capacity.join('-')}`,
-            svgId: 'number-of-seats',
+            name: `Seats ${poi.capacity.join("-")}`,
+            svgId: "number-of-seats"
           });
         }
-        if (poi.category.startsWith('meeting')) {
+        if (poi.category.startsWith("meeting")) {
           addToRoomInfo(poi, {
-            name: app.gt()('poiView:Conference Room'),
-            svgId: 'conference-room',
+            name: app.gt()("poiView:Conference Room"),
+            svgId: "conference-room"
           });
         }
-
         const roomId = getRoomId(poi);
         if (roomId) {
           poi.roomId = roomId;
         }
-
         return [poi.poiId, fixPositionInfo(poi, structuresLookup)];
       }),
-      R__namespace.fromPairs,
+      R__namespace.fromPairs
     )(pois);
   };
-
   const addToRoomInfo = (poi, value) => {
     if (!poi.roomInfo) {
       poi.roomInfo = [];
     }
     poi.roomInfo.push(value);
   };
-
   const getRoomId = R__namespace.pipe(
-    R__namespace.propOr([], 'externalIds'),
-    R__namespace.find(R__namespace.propEq('roomId', 'type')),
-    R__namespace.prop('id'),
-    R__namespace.unless(R__namespace.isNil, R__namespace.tail),
+    R__namespace.propOr([], "externalIds"),
+    R__namespace.find(R__namespace.propEq("roomId", "type")),
+    R__namespace.prop("id"),
+    R__namespace.unless(R__namespace.isNil, R__namespace.tail)
   );
-
   async function checkNavgraph(pois) {
     const start = Date.now();
     const badPois = [];
-    const navGraph = await app.bus.get('wayfinder/_getNavGraph');
-    Object.values(pois).forEach(poi => {
+    const navGraph = await app.bus.get("wayfinder/_getNavGraph");
+    Object.values(pois).forEach((poi) => {
       try {
         const pos = poi.position;
         const n = navGraph.findClosestNode(pos.floorId, pos.latitude, pos.longitude);
         if (!n) {
-          badPois.push({ id: poi.poiId, e: 'No closest Navgraph Node' });
+          badPois.push({ id: poi.poiId, e: "No closest Navgraph Node" });
         }
       } catch (e) {
         log.error(e);
         badPois.push({ id: poi.poiId, e: e.message });
       }
     });
-
     if (badPois.length) {
-      log.warn('badPois:', badPois);
+      log.warn("badPois:", badPois);
     }
-
     log(`Total time for navgraph POI check: ${Date.now() - start}ms`);
   }
-
   function filterBadPois(pois) {
     const badPois = [];
-    Object.values(pois).forEach(poi => {
+    Object.values(pois).forEach((poi) => {
       try {
         const pos = poi.position;
         if (!pos) {
-          badPois.push({ poi, e: 'No position information' });
+          badPois.push({ poi, e: "No position information" });
         } else {
-          ['buildingId', 'structureName', 'floorId', 'floorName', 'floorOrdinal', 'latitude', 'longitude'].forEach(
-            k => {
-              if (pos[k] === null || pos[k] === undefined) {
+          ["buildingId", "structureName", "floorId", "floorName", "floorOrdinal", "latitude", "longitude"].forEach(
+            (k) => {
+              if (pos[k] === null || pos[k] === void 0) {
                 badPois.push({
                   id: poi.poiId,
-                  e: `invalid position property: ${k}: ${pos[k]}`,
+                  e: `invalid position property: ${k}: ${pos[k]}`
                 });
               }
-            },
+            }
           );
         }
       } catch (e) {
@@ -145,171 +133,128 @@ async function create(app) {
         badPois.push({ id: poi.poiId, e: e.message });
       }
     });
-
     if (badPois.length) {
-      log.warn('badPois:', badPois);
-      badPois.forEach(ob => {
+      log.warn("badPois:", badPois);
+      badPois.forEach((ob) => {
         delete pois[ob.id];
       });
     }
-
     return pois;
   }
-
   async function enhanceImages(pois) {
     for (const poi of Object.values(pois)) {
       await addImages(poi);
     }
-
     return pois;
   }
-
-  app.bus.on('venueData/poiDataLoaded', async ({ pois, structures }) => {
+  app.bus.on("venueData/poiDataLoaded", async ({ pois, structures }) => {
     const structuresLookup = buildStructureLookup.buildStructuresLookup(structures);
     pois = formatPois(pois, structuresLookup);
-    if (configUtils.debugIsTrue(app, 'pseudoTransPois')) {
+    if (configUtils.debugIsTrue(app, "pseudoTransPois")) {
       for (const id in pois) {
         pois[id] = pseudoTransPoi(pois[id], app.i18n().language);
       }
     }
-
     pois = filterBadPois(pois);
-
     await enhanceImages(pois);
     poisLoaded.resolve(pois);
-
     if (app.config.debug && app.env.isBrowser) {
       window._pois = pois;
     }
-
     if (app.config.debug) {
       checkNavgraph(pois);
-    } // this doesn't change the pois, but warns in the console...
+    }
   });
-
-  app.bus.on('poi/getById', async ({ id }) => {
-    return poisLoaded.then(pois => pois[id]);
+  app.bus.on("poi/getById", async ({ id }) => {
+    return poisLoaded.then((pois) => pois[id]);
   });
-
-  app.bus.on('poi/getByFloorId', async ({ floorId }) =>
-    poisLoaded.then(R__namespace.pickBy(R__namespace.pathEq(floorId, ['position', 'floorId']))),
+  app.bus.on(
+    "poi/getByFloorId",
+    async ({ floorId }) => poisLoaded.then(R__namespace.pickBy(R__namespace.pathEq(floorId, ["position", "floorId"])))
   );
-
-  app.bus.on('poi/getByCategoryId', async ({ categoryId }) => {
-    // returns true for exact category matches or parent category matches
-    const categoryMatch = poi => poi.category === categoryId || poi.category.startsWith(categoryId + '.');
+  app.bus.on("poi/getByCategoryId", async ({ categoryId }) => {
+    const categoryMatch = (poi) => poi.category === categoryId || poi.category.startsWith(categoryId + ".");
     return poisLoaded.then(R__namespace.pickBy(categoryMatch));
   });
-
-  app.bus.on('poi/getAll', async () => poisLoaded);
-
-  const checkpointPath = ['queue', 'primaryQueueId'];
-  const addOtherSecurityLanesIfNeeded = async poi => {
+  app.bus.on("poi/getAll", async () => poisLoaded);
+  const checkpointPath = ["queue", "primaryQueueId"];
+  const addOtherSecurityLanesIfNeeded = async (poi) => {
     const primaryCheckpointId = R__namespace.path(checkpointPath, poi);
-
     if (!primaryCheckpointId) {
       return poi;
     }
-
-    const queueTypes = await app.bus.get('venueData/getQueueTypes');
-    const securityPoisMap = await app.bus.get('poi/getByCategoryId', {
-      categoryId: 'security',
+    const queueTypes = await app.bus.get("venueData/getQueueTypes");
+    const securityPoisMap = await app.bus.get("poi/getByCategoryId", {
+      categoryId: "security"
     });
     const securityPoisList = Object.values(securityPoisMap);
-
     poi.queue.otherQueues = prepareOtherSecurityLanes(queueTypes, poi, securityPoisList);
     return poi;
   };
-
   const prepareOtherSecurityLanes = (queueTypes, currentPoi, securityPois) => {
-    const queueTypePath = ['queue', 'queueType'];
+    const queueTypePath = ["queue", "queueType"];
     const queueType = R__namespace.path(queueTypePath, currentPoi);
     if (!queueType) {
       return null;
     }
-
     const queueSubtypes = queueTypes[queueType];
     const primaryCheckpointId = R__namespace.path(checkpointPath, currentPoi);
-    return securityPois
-      .filter(R__namespace.pathEq(primaryCheckpointId, checkpointPath)) // filter only connected security checkpoints
-      .filter(poi => poi.poiId !== currentPoi.poiId) // skip current poi
-      .map(poi => {
-        const laneId = R__namespace.path(['queue', 'queueSubtype'], poi);
-        const lane = getLaneData(laneId)(queueSubtypes);
-        return { poiId: poi.poiId, ...lane };
-      });
+    return securityPois.filter(R__namespace.pathEq(primaryCheckpointId, checkpointPath)).filter((poi) => poi.poiId !== currentPoi.poiId).map((poi) => {
+      const laneId = R__namespace.path(["queue", "queueSubtype"], poi);
+      const lane = getLaneData(laneId)(queueSubtypes);
+      return { poiId: poi.poiId, ...lane };
+    });
   };
-
-  // if the value passed is non-null, simply return it. Else throw the error with the message specified.
-  // This is useful to insert into pipelines.
-  const ensureDefined = errorMsg => value => {
+  const ensureDefined = (errorMsg) => (value) => {
     if (value != null) {
       return value;
     }
     throw Error(errorMsg);
   };
-
-  const getLaneData = laneId =>
-    R__namespace.pipe(
-      R__namespace.find(R__namespace.propEq(laneId, 'id')),
-      ensureDefined(`No queue found with ID: ${laneId}`),
-      R__namespace.pick(['displayText', 'imageId']),
-    );
-
-  /**
-   * Updates security checkpoint POI with a list of related security checkpoints.
-   */
-  app.bus.on('poi/addOtherSecurityLanes', ({ poi }) => addOtherSecurityLanesIfNeeded(poi));
-
-  const isFullUrl = url => !!url?.startsWith('https:');
-
+  const getLaneData = (laneId) => R__namespace.pipe(
+    R__namespace.find(R__namespace.propEq(laneId, "id")),
+    ensureDefined(`No queue found with ID: ${laneId}`),
+    R__namespace.pick(["displayText", "imageId"])
+  );
+  app.bus.on("poi/addOtherSecurityLanes", ({ poi }) => addOtherSecurityLanesIfNeeded(poi));
+  const isFullUrl = (url) => !!url?.startsWith("https:");
   async function addImages(poi) {
     if (!poi) {
       return;
     }
-    const dpr = typeof window === 'undefined' ? 1 : window.devicePixelRatio || 1;
+    const dpr = typeof window === "undefined" ? 1 : window.devicePixelRatio || 1;
     const size = `${Math.round(351 * dpr)}x${Math.round(197 * dpr)}`;
-
     if (!R__namespace.length(poi.images)) {
       poi.images = [];
     } else if (!isFullUrl(poi.images[0])) {
-      // then images are not yet transformed
       poi.images = await Zousan.all(
-        poi.images.map(imageName => app.bus.get('venueData/getPoiImageUrl', { imageName, size })),
+        poi.images.map((imageName) => app.bus.get("venueData/getPoiImageUrl", { imageName, size }))
       );
     }
-
     if (!R__namespace.length(poi.fullImages)) {
       poi.fullImages = [];
     } else if (!isFullUrl(poi.fullImages[0]?.url)) {
-      // then images are not yet transformed
       poi.fullImages = await Zousan.all(
         poi.fullImages.map(async ({ url, ...rest }) => {
-          const fullUrl = await app.bus.get('venueData/getPoiImageUrl', {
+          const fullUrl = await app.bus.get("venueData/getPoiImageUrl", {
             imageName: url,
-            size,
+            size
           });
           return { url: fullUrl, ...rest };
-        }),
+        })
       );
     }
-
     return poi;
   }
-
-  const getUniqueCategories = R__namespace.memoizeWith(R__namespace.identity, R__namespace.pipe(R__namespace.pluck('category'), R__namespace.values, R__namespace.uniq));
-  app.bus.on('poi/getAllCategories', async () => poisLoaded.then(getUniqueCategories));
-
-  app.bus.on('venueData/loadNewVenue', () => {
+  const getUniqueCategories = R__namespace.memoizeWith(R__namespace.identity, R__namespace.pipe(R__namespace.pluck("category"), R__namespace.values, R__namespace.uniq));
+  app.bus.on("poi/getAllCategories", async () => poisLoaded.then(getUniqueCategories));
+  app.bus.on("venueData/loadNewVenue", () => {
     poisLoaded = new Zousan();
     init();
   });
-
-  // See architectural document at  https://docs.google.com/document/d/1NoBAboHR9BiX_vvLef-vp3ButrIQDWYofcTsdilEWvs/edit#
-  app.bus.on('poi/setDynamicData', ({ plugin, idValuesMap }) => {
-    poisLoaded.then(pois => {
+  app.bus.on("poi/setDynamicData", ({ plugin, idValuesMap }) => {
+    poisLoaded.then((pois) => {
       for (const poiId in idValuesMap) {
-        // const dd = { [plugin]: idValuesMap[poiId] }
         const dynamicData = pois[poiId].dynamicData || {};
         dynamicData[plugin] = { ...idValuesMap[poiId] };
         const newPoi = R__namespace.mergeRight(pois[poiId], { dynamicData });
@@ -317,70 +262,55 @@ async function create(app) {
       }
     });
   });
-
-  // Applies or reverts dynamic name overrides on POIs.
-  // A null name value reverts to the original name stashed before the first override.
-  app.bus.on('poi/setCoreAttributes', idAttributesMap => {
-    poisLoaded.then(pois => {
+  app.bus.on("poi/setCoreAttributes", (idAttributesMap) => {
+    poisLoaded.then((pois) => {
       for (const poiId in idAttributesMap) {
-        applyCorePoiAttributes(pois, poiId, idAttributesMap[poiId]);
+        const changed = applyCorePoiAttributes(pois, poiId, idAttributesMap[poiId]);
+        if (changed) {
+          app.bus.send("map/mutateFeature", { poiId, name: pois[poiId].name });
+        }
       }
     });
   });
-
-  const runTest = async testRoutine => {
+  const runTest = async (testRoutine) => {
     await testRoutine();
     return poisLoaded;
   };
-
   return {
     init,
     runTest,
     internal: {
       addImages,
       pseudoTransPoi,
-      applyCorePoiAttributes,
-    },
+      applyCorePoiAttributes
+    }
   };
 }
-
-/**
- * Applies or reverts a single POI's core attributes.
- *
- * - A `null` name reverts the POI to the original name stashed before the first override.
- * - Any other name value stashes the original (if not already stashed) then applies the override.
- *
- * @param {Object} pois - Mutable map of POI id → POI object.
- * @param {string} poiId - ID of the POI to update.
- * @param {Object} attributes - Attributes to apply (currently supports `name`).
- */
 function applyCorePoiAttributes(pois, poiId, attributes) {
   if (!pois[poiId]) {
-    return;
+    return false;
   }
   const { name } = attributes;
-  if (name === null) {
-    // Revert: restore original name from before first override
+  if (!name) {
     pois[poiId] = R__namespace.mergeRight(pois[poiId], {
-      name: pois[poiId]._originalName ?? pois[poiId].name,
+      name: pois[poiId]._originalName ?? pois[poiId].name
     });
   } else {
-    // First override: stash original name before clobbering
     if (!pois[poiId]._originalName) {
       pois[poiId] = R__namespace.mergeRight(pois[poiId], { _originalName: pois[poiId].name });
     }
     pois[poiId] = R__namespace.mergeRight(pois[poiId], { name });
   }
+  return true;
 }
-
 function pseudoTransPoi(poi, lang) {
-  ['description', 'nearbyLandmark', 'name', 'phone', 'operationHours'].forEach(p => {
+  ["description", "nearbyLandmark", "name", "phone", "operationHours"].forEach((p) => {
     if (poi[p]) {
       poi[p] = i18n.toLang(poi[p], lang);
     }
   });
   if (poi.keywords) {
-    poi.keywords = poi.keywords.map(keyword => {
+    poi.keywords = poi.keywords.map((keyword) => {
       keyword.name = i18n.toLang(keyword.name, lang);
       return keyword;
     });

package/dist/cjs/plugins/sdkServer/src/prepareSDKConfig.js

@@ -42,43 +42,35 @@ function prepareSDKConfig(sc) {
     pinnedLocationZoom,
     pinnedLocationFocusAtStart,
     pinnedLocationBearing,
-    pinnedLocationPitch,
+    pinnedLocationPitch
   } = sc;
-
-  const extendsConfig = parentConfig ? [parentConfig] : headless ? ['sdkHeadless'] : ['sdkVisual'];
-
-  const trunc = (str, len) => (str && str.length > len ? str.substring(0, len) : str);
-
-  const validateHostAppId = hostAppId => (hostAppId ? trunc(hostAppId.toString(), 128) : undefined);
-  const validateHostAppVersion = hostAppVersion => (hostAppVersion ? trunc(hostAppVersion.toString(), 128) : undefined);
-  const validateHostAppProperties = hostAppProperties => {
-    if (!hostAppProperties || typeof hostAppProperties !== 'object') {
-      return undefined;
+  const extendsConfig = parentConfig ? [parentConfig] : headless ? ["sdkHeadless"] : ["sdkVisual"];
+  const trunc = (str, len) => str && str.length > len ? str.substring(0, len) : str;
+  const validateHostAppId = (hostAppId2) => hostAppId2 ? trunc(hostAppId2.toString(), 128) : void 0;
+  const validateHostAppVersion = (hostAppVersion2) => hostAppVersion2 ? trunc(hostAppVersion2.toString(), 128) : void 0;
+  const validateHostAppProperties = (hostAppProperties2) => {
+    if (!hostAppProperties2 || typeof hostAppProperties2 !== "object") {
+      return void 0;
     }
-
-    const ret = {}; // lets build this back up ourselves to ensure its purity
-    const keys = Object.keys(hostAppProperties);
-
+    const ret = {};
+    const keys = Object.keys(hostAppProperties2);
     if (keys.length > 10) {
       keys.length = 10;
     }
-
-    keys.forEach(key => {
-      let cleanKey = trunc(key.toString().replaceAll(/[^a-zA-Z0-9_]/g, ''), 128);
+    keys.forEach((key) => {
+      let cleanKey = trunc(key.toString().replaceAll(/[^a-zA-Z0-9_]/g, ""), 128);
       if (!cleanKey.match(/^[a-zA-Z]+/)) {
-        cleanKey = 'X' + cleanKey;
-      } // force to start with alpha char
-      let cleanVal = hostAppProperties[key];
-      if (cleanVal === null || cleanVal === undefined) {
-        cleanVal = '';
+        cleanKey = "X" + cleanKey;
+      }
+      let cleanVal = hostAppProperties2[key];
+      if (cleanVal === null || cleanVal === void 0) {
+        cleanVal = "";
       }
       cleanVal = trunc(cleanVal.toString(), 128);
       ret[cleanKey] = cleanVal;
     });
-
     return ret;
   };
-
   const config = {
     name,
     engineName,
@@ -93,116 +85,93 @@ function prepareSDKConfig(sc) {
       venueDataLoader: {
         dataFetch,
         venueId,
-        accountId,
+        accountId
       },
       sdkServer: {
-        headless,
+        headless
       },
       analytics2: {
         hostAppId: validateHostAppId(hostAppId),
         hostAppVersion: validateHostAppVersion(hostAppVersion),
-        hostAppProperties: validateHostAppProperties(hostAppProperties),
-      },
+        hostAppProperties: validateHostAppProperties(hostAppProperties)
+      }
     },
-    uuid: typeof document !== 'undefined' && document && document.location ? document.location.host : 'unknown', // used in analytics
+    uuid: typeof document !== "undefined" && document && document.location ? document.location.host : "unknown"
+    // used in analytics
   };
-
-  if (analytics2ActiveFlag !== undefined) {
+  if (analytics2ActiveFlag !== void 0) {
     config.plugins.analytics2.active = analytics2ActiveFlag;
   }
-
-  // return an object with the named property set to the specified value, unless the
-  // value is undefined, then return an empty object
-  const setIfDef = (name, value) => (value !== undefined ? { [name]: value } : {});
-
+  const setIfDef = (name2, value) => value !== void 0 ? { [name2]: value } : {};
   if (!headless) {
-    config.plugins['online/headerOnline'] = { searchPlaceholder };
+    config.plugins["online/headerOnline"] = { searchPlaceholder };
     config.plugins.mapRenderer = {
-      ...setIfDef('enablePoiSelection', enablePoiSelection),
+      ...setIfDef("enablePoiSelection", enablePoiSelection),
       surroundConfig: showSurround ? {} : null,
       viewLimits: {
-        ...setIfDef('maxZoom', maxZoom),
-        ...setIfDef('minZoom', minZoom),
-      },
+        ...setIfDef("maxZoom", maxZoom),
+        ...setIfDef("minZoom", minZoom)
+      }
     };
     config.plugins.userMenu = { noLangOptions };
     if (pinnedLocation) {
-      config.plugins['online/pinnedLocation'] = {
+      config.plugins["online/pinnedLocation"] = {
         location: pinnedLocation,
         zoom: pinnedLocationZoom,
         focusAtStart: pinnedLocationFocusAtStart,
         bearing: pinnedLocationBearing,
-        pitch: pinnedLocationPitch,
+        pitch: pinnedLocationPitch
       };
     }
   }
-
   config.plugins.searchService = defaultSearchTerms ? { defaultSearchTerms } : {};
-  handleI18NParm(sc, 'defaultSearchTerms', config.plugins.searchService);
-
-  if (extendsConfig.includes('sdkVisual')) {
+  handleI18NParm(sc, "defaultSearchTerms", config.plugins.searchService);
+  if (extendsConfig.includes("sdkVisual")) {
     if (poiCategories) {
-      config.plugins['online/homeView'] = { poiCategories };
+      config.plugins["online/homeView"] = { poiCategories };
     } else {
-      config.plugins['online/homeView'] = {};
+      config.plugins["online/homeView"] = {};
     }
-    handleI18NParm(sc, 'poiCategories', config.plugins['online/homeView']);
+    handleI18NParm(sc, "poiCategories", config.plugins["online/homeView"]);
   }
-  // Allow *specific* additional plugins
-  // for now, this is just for internal use
   if (plugins) {
     if (plugins.draw) {
       config.plugins.draw = plugins.draw;
     }
-    // To get flight status working, one needs 3 plugins.  This is a bad design, there should just be one and it provides
-    // all 3 of these services. Lets migrate to a single plugin at some point - but until then, lets at least make it look
-    // like a single plugin for SDK users. The only plugin that currently has configurable properties is "flightStatus" - so
-    // lets let SDK users define that one and its single property (apiKey) and we'll just create the other two by default.
     if (plugins.flightStatus) {
       config.plugins.flightStatus = plugins.flightStatus;
-      config.plugins['online/flightDetails'] = {}; // these really shouldn't be separate plugins (!)
-      config.plugins['online/flightDetailsSearch'] = {}; // these really shouldn't be separate plugins (!)
+      config.plugins["online/flightDetails"] = {};
+      config.plugins["online/flightDetailsSearch"] = {};
     }
   }
-
   if (preserveStateInURL) {
-    config.configPostProc.push('stateTracking');
+    config.configPostProc.push("stateTracking");
     config.plugins.deepLinking = { trackURL: true };
   }
-
   if (supportURLDeepLinks) {
-    config.configPostProc.push('mol-url-parms');
+    config.configPostProc.push("mol-url-parms");
   }
-
   if (initState) {
     postprocStateTracking.setStateFromStateString(config, funcs.b64DecodeUnicode(initState), true);
   }
-
   if (deepLinkParms) {
     postprocMolUrlParms.setDeepLinksForParms(config, new URLSearchParams(deepLinkParms), true);
   }
-
-  if (desktopViewMinWidth !== undefined) {
+  if (desktopViewMinWidth !== void 0) {
     config.desktopViewMinWidth = desktopViewMinWidth;
   }
-
   if (forceDesktop) {
     config.desktopViewMinWidth = 0;
   }
-
   if (dynamicPoisUrlBaseV1) {
     config.plugins.dynamicPois = {
-      urlBaseV1: dynamicPoisUrlBaseV1,
+      urlBaseV1: dynamicPoisUrlBaseV1
     };
   }
-
-  return funcs.filterOb((k, v) => v !== undefined, config); // remove any undefined values
+  return funcs.filterOb((k, v) => v !== void 0, config);
 }
-
 function handleI18NParm(sdkConfig, prefix, configDest) {
-  Object.keys(sdkConfig)
-    .filter(key => key.startsWith(prefix + '-'))
-    .forEach(key => (configDest[key] = sdkConfig[key]));
+  Object.keys(sdkConfig).filter((key) => key.startsWith(prefix + "-")).forEach((key) => configDest[key] = sdkConfig[key]);
 }
 
 module.exports = prepareSDKConfig;