atriusmaps-node-sdk/dist/cjs/plugins/dynamicPois/src/processors.js

This project provides an API to Atrius Personal Wayfinder maps within a Node environment. See the README.md for more information

'use strict';

var R = require('ramda');

function _interopNamespaceDefault(e) {
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);

const mutateSecurityCheckpointLabel = (T, queueTimes, labels) => (feature) => {
  const id = feature.properties.id;
  const dynamicData = queueTimes[id];
  const label = labels[id];
  if (dynamicData) {
    const { queueTime, isTemporarilyClosed } = dynamicData;
    const secondaryText = isTemporarilyClosed ? T("ui:Closed") : T("ui:_xx_ minute wait", { count: queueTime });
    feature.properties.text = `${label}
${secondaryText}`;
  }
  return feature;
};
const mutatePoiName = (_T, nameOverrides, originalNames) => (feature) => {
  const id = feature.properties?.id;
  const override = id !== void 0 && nameOverrides?.[String(id)];
  if (!override) {
    return feature;
  }
  const { name } = override;
  if (name === null) {
    const original = originalNames?.[String(id)];
    if (original) {
      feature.properties.text = original;
    }
  } else {
    feature.properties.text = name;
  }
  return feature;
};
const processParkingPOIS = (poiMap) => {
  const idValuesMap = R__namespace.pipe(
    R__namespace.filter((poi) => poi.category === "parking"),
    R__namespace.map((poi) => {
      const da = poi.dynamicAttributes;
      if (!da) {
        throw Error(`No dynamicAttributes defined for parking POI ${poi.poiId}`);
      }
      const age = (Date.now() - poi.timestamp) / 1e3;
      const currencyProps = {
        ...poi.currencyCode !== void 0 && { currencyCode: poi.currencyCode },
        ...poi.currencySymbol !== void 0 && { currencySymbol: poi.currencySymbol }
      };
      const props = age < da["parking.timeToLive"] ? {
        ...R__namespace.pick(["lotStatus", "rateDay", "rateHour", "timeIsReal", "timeToTerminal1", "timeToTerminal2"], poi),
        ...currencyProps
      } : {
        lotStatus: da["parking.default"],
        rateDay: `${poi.currencySymbol ?? "$"} -`,
        rateHour: `${poi.currencySymbol ?? "$"} -`,
        timeIsReal: false,
        ...currencyProps
      };
      return { ...props, lastUpdated: poi.timestamp, lotName: poi.lotName };
    })
  )(poiMap);
  return idValuesMap;
};
const processOpenClosedPois = (poiMap) => {
  const pathToOpenClosedData = ["dynamicData", "openClosed"];
  const openClosedPois = R__namespace.filter(R__namespace.hasPath(pathToOpenClosedData), poiMap);
  const openClosedStatuses = R__namespace.map(R__namespace.path(pathToOpenClosedData), openClosedPois);
  if (R__namespace.all(R__namespace.both(R__namespace.has("isOpen"), R__namespace.has("expiration")), R__namespace.values(openClosedStatuses))) {
    const isExpired = R__namespace.pipe(R__namespace.prop("expiration"), R__namespace.lt(Date.now()));
    const idValuesMap = R__namespace.filter(isExpired, openClosedStatuses);
    return idValuesMap;
  } else {
    throw Error("Open Closed poi status is malformed.");
  }
};
const processSecurityWaitTimes = (poiMap) => {
  const queuePath = ["dynamicData", "queue"];
  const queuePois = R__namespace.filter(R__namespace.hasPath(queuePath), poiMap);
  const queues = R__namespace.map(R__namespace.path(queuePath), queuePois);
  return R__namespace.map(
    (queue) => ({
      isTemporarilyClosed: queue.isTemporarilyClosed,
      queueTime: queue.queueTime,
      timeIsReal: !queue.isQueueTimeDefault && queue.expiration > Date.now(),
      lastUpdated: Date.now()
    }),
    queues
  );
};
const processRoutingPois = (poiMap) => {
  const now = Date.now();
  return R__namespace.filter((poi) => {
    const navGraphHidden = R__namespace.path(["dynamicData", "dynamic-routing", "navGraphHidden"], poi);
    const expiration = R__namespace.path(["dynamicData", "dynamic-routing", "expiration"], poi);
    return navGraphHidden === true && expiration > now;
  }, poiMap);
};

exports.mutatePoiName = mutatePoiName;
exports.mutateSecurityCheckpointLabel = mutateSecurityCheckpointLabel;
exports.processOpenClosedPois = processOpenClosedPois;
exports.processParkingPOIS = processParkingPOIS;
exports.processRoutingPois = processRoutingPois;
exports.processSecurityWaitTimes = processSecurityWaitTimes;