@openfn/language-varo 1.0.0

package/dist/index.cjs

@@ -0,0 +1,392 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  alterState: () => import_language_common2.alterState,
+  combine: () => import_language_common2.combine,
+  convertToEms: () => convertToEms,
+  cursor: () => import_language_common2.cursor,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  default: () => src_default,
+  each: () => import_language_common2.each,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  fnIf: () => import_language_common2.fnIf,
+  http: () => import_language_common2.http,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  sourceValue: () => import_language_common2.sourceValue
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  alterState: () => import_language_common2.alterState,
+  combine: () => import_language_common2.combine,
+  convertToEms: () => convertToEms,
+  cursor: () => import_language_common2.cursor,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  each: () => import_language_common2.each,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  fnIf: () => import_language_common2.fnIf,
+  http: () => import_language_common2.http,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  sourceValue: () => import_language_common2.sourceValue
+});
+var import_language_common = require("@openfn/language-common");
+var import_util = require("@openfn/language-common/util");
+
+// src/Utils.js
+function parseMetadata(message) {
+  var _a;
+  if (!((_a = message.metadata) == null ? void 0 : _a.content)) {
+    console.error("No metadata supplied.");
+    return null;
+  }
+  try {
+    return JSON.parse(message.metadata.content);
+  } catch (error) {
+    console.error("Invalid metadata JSON.", error);
+    return null;
+  }
+}
+
+// src/VaroEmsUtils.js
+function parseVaroEmsToEms(metadata, data, dataPath2) {
+  const result = {
+    CID: null,
+    LAT: metadata.location.used.latitude,
+    LNG: metadata.location.used.longitude,
+    ADOP: data.ADOP,
+    AMFR: data.AMFR,
+    AMOD: data.AMOD,
+    APQS: data.APQS,
+    ASER: data.ASER,
+    EDOP: null,
+    EMFR: null,
+    EMOD: null,
+    EPQS: null,
+    ESER: null,
+    EMSV: null,
+    LDOP: data.LDOP,
+    LMFR: data.LMFR,
+    LMOD: data.LMOD,
+    LPQS: data.LPQS,
+    LSER: data.LSER,
+    LSV: data.LSV,
+    records: []
+  };
+  const deviceDate = parseRelativeDateFromUsbPluggedInfo(dataPath2);
+  for (const item of data.records) {
+    const durations = [item.RELT];
+    const absoluteDate = parseAdjustedDate(deviceDate, durations);
+    const abst = parseIsoToAbbreviatedIso(absoluteDate);
+    const record = {
+      ABST: abst,
+      ALRM: null,
+      BEMD: null,
+      BLOG: item.BLOG,
+      CMPR: null,
+      DORV: item.DORV,
+      HAMB: null,
+      HOLD: item.HOLD,
+      LERR: item.LERR,
+      EERR: null,
+      SVA: null,
+      TAMB: item.TAMB,
+      TVC: item.TVC
+    };
+    result.records.push(record);
+  }
+  return result;
+}
+function parseRelativeDateFromUsbPluggedInfo(path) {
+  const regex = /_CURRENT_DATA_(?<duration>\w+?)_(?<date>\w+?)\.json$/;
+  const match = path.match(regex);
+  if (!match) {
+    throw new Error(`Path format is incorrect: ${path}`);
+  }
+  const usbPluggedInfo = {
+    date: match.groups.date,
+    duration: match.groups.duration
+  };
+  const isoDate = parseAbbreviatedIsoToIso(usbPluggedInfo.date);
+  return parseAdjustedDate(isoDate, [usbPluggedInfo.duration], true);
+}
+function parseAdjustedDate(incomingDate, durations, subtract = false) {
+  function parseDuration(duration) {
+    const regex = /^P((?<days>\d+)D)?(T((?<hours>\d+)H)?((?<minutes>\d+)M)?((?<seconds>\d+)S)?)?$/;
+    const match = duration.match(regex);
+    if (!match) {
+      throw new Error(`Invalid duration format: ${duration}`);
+    }
+    const multiplier = subtract ? -1 : 1;
+    const days = parseInt(match.groups.days || 0, 10) * multiplier;
+    const hours = parseInt(match.groups.hours || 0, 10) * multiplier;
+    const minutes = parseInt(match.groups.minutes || 0, 10) * multiplier;
+    const seconds = parseInt(match.groups.seconds || 0, 10) * multiplier;
+    if (days === 0 && hours === 0 && minutes === 0 && seconds === 0) {
+      return null;
+    }
+    return { days, hours, minutes, seconds };
+  }
+  function applyDuration(date, duration) {
+    date.setDate(date.getDate() + duration.days);
+    date.setHours(date.getHours() + duration.hours);
+    date.setMinutes(date.getMinutes() + duration.minutes);
+    date.setSeconds(date.getSeconds() + duration.seconds);
+  }
+  const adjustedDate = new Date(incomingDate);
+  for (const duration of durations) {
+    if (!duration)
+      continue;
+    const parsedDuration = parseDuration(duration);
+    if (!parsedDuration)
+      continue;
+    applyDuration(adjustedDate, parsedDuration);
+  }
+  return adjustedDate;
+}
+function parseAbbreviatedIsoToIso(abbreviatedIso) {
+  const regex = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z$/;
+  const match = abbreviatedIso.match(regex);
+  if (!match) {
+    throw new Error(`Invalid abbreviated ISO date format: ${abbreviatedIso}`);
+  }
+  return `${match[1]}-${match[2]}-${match[3]}T${match[4]}:${match[5]}:${match[6]}Z`;
+}
+function parseIsoToAbbreviatedIso(iso) {
+  return iso.toISOString().replace(/[\-\:]/g, "").replace(".000Z", "Z");
+}
+
+// src/FridgeTagUtils.js
+function parseFridgeTagToEms(metadata, nodes) {
+  const result = {
+    records: [],
+    reports: []
+  };
+  applyMetadataToResult();
+  applyNodesToResult();
+  function applyMetadataToResult() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    applyPropertyToResult("AMFR", (_a = metadata == null ? void 0 : metadata.refrigerator) == null ? void 0 : _a.manufacturer);
+    applyPropertyToResult("AMOD", (_b = metadata == null ? void 0 : metadata.refrigerator) == null ? void 0 : _b.model);
+    applyPropertyToResult("LMFR", (_c = metadata == null ? void 0 : metadata.refrigerator) == null ? void 0 : _c.deviceManufacturer);
+    applyPropertyToResult("CID", (_d = metadata == null ? void 0 : metadata.facility) == null ? void 0 : _d.country);
+    applyPropertyToResult("LAT", (_f = (_e = metadata == null ? void 0 : metadata.location) == null ? void 0 : _e.used) == null ? void 0 : _f.latitude);
+    applyPropertyToResult("LNG", (_h = (_g = metadata == null ? void 0 : metadata.location) == null ? void 0 : _g.used) == null ? void 0 : _h.longitude);
+    applyPropertyToResult("LACC", (_j = (_i = metadata == null ? void 0 : metadata.location) == null ? void 0 : _i.used) == null ? void 0 : _j.accuracy);
+  }
+  function applyNodesToResult() {
+    var _a, _b, _c;
+    applyPropertyToResult("LMOD", nodes["Device"]);
+    applyPropertyToResult("LSER", (_a = nodes["Conf"]) == null ? void 0 : _a["Serial"]);
+    applyPropertyToResult("LSV", nodes["Fw Vers"]);
+    let productionDate = (_b = nodes["Conf"]) == null ? void 0 : _b["Test TS"];
+    productionDate = productionDate ? new Date(productionDate) : null;
+    applyPropertyToResult("LDOP", productionDate);
+    let dayIndex = 1;
+    let dayNode;
+    while ((dayNode = (_c = nodes["Hist"]) == null ? void 0 : _c[dayIndex++]) !== void 0) {
+      applyDayToRecords(dayNode);
+      applyDayToReports(dayNode);
+    }
+  }
+  function applyPropertyToResult(property, text) {
+    if (!text)
+      return;
+    result[property] = text;
+  }
+  function applyDayToRecords(dayNode) {
+    applyNodeToRecords(dayNode, "TS Min T", "Min T", "0", "FRZE");
+    applyNodeToRecords(dayNode, "TS Max T", "Max T", "1", "HEAT");
+    function applyNodeToRecords(dayNode2, timeField, tempField, alarmField, alarmDescription) {
+      var _a;
+      const date = dayNode2["Date"];
+      const time = dayNode2[timeField];
+      const dateTime = new Date(`${date}T${time}:00Z`);
+      const temp = parseFloat(dayNode2[tempField]);
+      const alarm = parseAlarm(
+        (_a = dayNode2["Alarm"]) == null ? void 0 : _a[alarmField],
+        alarmDescription
+      );
+      result.records.push({
+        ABST: dateTime,
+        TVC: temp,
+        ALRM: alarm,
+        description: date + " " + tempField
+      });
+      function parseAlarm(alarmNode, description) {
+        if (alarmNode["t Acc"] === "0")
+          return null;
+        return description + (alarmNode["C A"] !== "0" ? "ACK" : "");
+      }
+    }
+  }
+  function applyDayToReports(dayNode) {
+    const report = {
+      date: new Date(dayNode["Date"]),
+      duration: "1D",
+      alarms: [],
+      aggregates: []
+    };
+    applyAlarmsToReport(dayNode);
+    applyAggregatesToReport(dayNode);
+    result.reports.push(report);
+    function applyAlarmsToReport(dayNode2) {
+      var _a, _b;
+      const date = dayNode2["Date"];
+      applyAlarmToAlarms((_a = dayNode2["Alarm"]) == null ? void 0 : _a["0"], "FRZE");
+      applyAlarmToAlarms((_b = dayNode2["Alarm"]) == null ? void 0 : _b["1"], "HEAT");
+      function applyAlarmToAlarms(alarmNode, description) {
+        if (!alarmNode)
+          return;
+        const minutes = parseInt(alarmNode["t Acc"]);
+        if (!minutes)
+          return;
+        const alarm = {
+          condition: description,
+          conditionMinutes: minutes
+        };
+        const time = alarmNode["TS A"];
+        if (time) {
+          alarm.alarmTime = new Date(`${date}T${time}:00Z`);
+        }
+        const count = parseInt(alarmNode["C A"]);
+        if (count) {
+          alarm.count = count;
+        }
+        report.alarms.push(alarm);
+      }
+    }
+    function applyAggregatesToReport(dayNode2) {
+      applyTvcToAggregates(dayNode2);
+      function applyTvcToAggregates(dayNode3) {
+        report.aggregates.push({
+          id: "TVC",
+          min: parseFloat(dayNode3["Min T"]),
+          max: parseFloat(dayNode3["Max T"]),
+          average: parseFloat(dayNode3["Avrg T"])
+        });
+      }
+    }
+  }
+  return result;
+}
+function parseFridgeTag(text) {
+  const result = {};
+  const properties = [{ indent: -1, property: result }];
+  for (const line of text.split("\n")) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine)
+      continue;
+    const indent = line.search(/\S/);
+    while (indent <= properties[properties.length - 1].indent) {
+      properties.pop();
+    }
+    const property = properties[properties.length - 1].property;
+    const segments = trimmedLine.split(",").map((s) => s.trim());
+    for (const segment of segments) {
+      const pair = getKeyValuePair(segment);
+      if (!pair)
+        continue;
+      if (pair.value) {
+        property[pair.key] = pair.value;
+      } else {
+        property[pair.key] = {};
+        properties.push({ indent, property: property[pair.key] });
+      }
+    }
+  }
+  return result;
+  function getKeyValuePair(segment) {
+    const colonIndex = segment.indexOf(":");
+    if (colonIndex === -1)
+      return null;
+    const key = segment.slice(0, colonIndex).trim();
+    const value = segment.slice(colonIndex + 1).trim();
+    return { key, value };
+  }
+}
+
+// src/Adaptor.js
+var import_language_common2 = require("@openfn/language-common");
+function convertToEms(messageContents) {
+  return async (state) => {
+    var _a, _b;
+    const [resolvedMessageContents] = (0, import_util.expandReferences)(state, messageContents);
+    const results = [];
+    console.log("Incoming message contents", resolvedMessageContents.length);
+    for (const content of resolvedMessageContents) {
+      if ((_a = content.fridgeTag) == null ? void 0 : _a.content) {
+        const metadata = parseMetadata(content);
+        if (!metadata)
+          continue;
+        const fridgeTagNodes = parseFridgeTag(content.fridgeTag.content);
+        const result = parseFridgeTagToEms(metadata, fridgeTagNodes);
+        results.push(result);
+        continue;
+      }
+      if ((_b = content.data) == null ? void 0 : _b.content) {
+        const metadata = parseMetadata(content);
+        if (!metadata)
+          continue;
+        const data = JSON.parse(content.data.content);
+        const dataPath2 = content.data.filename;
+        const result = parseVaroEmsToEms(metadata, data, dataPath2);
+        results.push(result);
+        continue;
+      }
+      console.error(
+        `Insufficient content found for MessageID: ${content.messageId}`
+      );
+    }
+    console.log("Converted message contents", results.length);
+    return { ...(0, import_language_common.composeNextState)(state, results) };
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alterState,
+  combine,
+  convertToEms,
+  cursor,
+  dataPath,
+  dataValue,
+  each,
+  field,
+  fields,
+  fn,
+  fnIf,
+  http,
+  lastReferenceValue,
+  merge,
+  sourceValue
+});