fluent-cerner-js 1.0.0 → 1.1.0-1

package/dist/index.cjs

@@ -0,0 +1,1091 @@
+"use strict";
+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.ts
+var index_exports = {};
+__export(index_exports, {
+  CclCallParam: () => import_easy_ccl_request.CclCallParam,
+  CclRequestResponse: () => import_easy_ccl_request.CclRequestResponse,
+  XmlCclReadyState: () => import_easy_ccl_request.XmlCclReadyState,
+  XmlCclResult: () => import_easy_ccl_request.XmlCclResult,
+  addAddendumToDocumentAsync: () => addAddendumToDocumentAsync,
+  createNewDocumentAsync: () => createNewDocumentAsync,
+  getValidEncountersAsync: () => getValidEncountersAsync,
+  launchClinicalNoteAsync: () => launchClinicalNoteAsync,
+  launchDischargeProcessAsync: () => launchDischargeProcessAsync,
+  launchPatientEducationAsync: () => launchPatientEducationAsync,
+  launchPowerFormAsync: () => launchPowerFormAsync,
+  launchPowerNoteAsync: () => launchPowerNoteAsync,
+  makeCclRequestAsync: () => import_easy_ccl_request.makeCclRequestAsync,
+  manageAppointmentAsync: () => manageAppointmentAsync,
+  openApplicationAsync: () => openApplicationAsync,
+  openOrganizerTabAsync: () => openOrganizerTabAsync,
+  openPatientTabAsync: () => openPatientTabAsync,
+  openWebsiteByUrlAsync: () => openWebsiteByUrlAsync,
+  submitOrdersAsync: () => submitOrdersAsync,
+  submitPowerOrdersAsync: () => submitPowerOrdersAsync
+});
+module.exports = __toCommonJS(index_exports);
+var import_easy_ccl_request = require("easy-ccl-request");
+
+// src/utils/index.ts
+function outsideOfPowerChartError(e) {
+  return e instanceof TypeError && /(MPAGES_EVENT|XMLCclRequest|APPLINK|DiscernObjectFactory) is not a function/i.test(
+    e.message
+  );
+}
+var warnAttemptedOrdersOutsideOfPowerChart = (eventString) => {
+  console.warn(`window.MPAGES_EVENT('ORDERS', '${eventString}')`);
+};
+
+// src/addAddendumToDocumentAsync.ts
+async function addAddendumToDocumentAsync(patientId, encounterId, eventId) {
+  let retVal = {
+    inPowerChart: true,
+    success: false
+  };
+  try {
+    const dcof = await window.external.DiscernObjectFactory("DYNDOC");
+    let response = null;
+    response = await dcof.ModifyExistingDocumentByEventId(
+      patientId,
+      encounterId,
+      eventId
+    );
+    retVal.success = Boolean(response);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retVal.inPowerChart = false;
+      return retVal;
+    } else {
+      throw e;
+    }
+  }
+  return retVal;
+}
+
+// src/createNewDocumentAsync.ts
+async function createNewDocumentAsync(method, patientId, encounterId, id, noteTypeCd) {
+  let retVal = {
+    inPowerChart: true,
+    success: false
+  };
+  try {
+    const dcof = await window.external.DiscernObjectFactory("DYNDOC");
+    let response = null;
+    if (method !== "by workflow" && method !== "by reference template") {
+      throw new Error(`createNewDocumentAsync: ${method} is not supported`);
+    }
+    if (method === "by workflow" && noteTypeCd) {
+      console.warn(
+        "The noteTypeCd is not used when creating a document by workflow."
+      );
+    }
+    if (method === "by workflow") {
+      response = await dcof.OpenDynDocByWorkFlowId(patientId, encounterId, id);
+    }
+    if (method === "by reference template" && !noteTypeCd) {
+      response = await dcof.OpenNewDocumentByReferenceTemplateId(
+        patientId,
+        encounterId,
+        id
+      );
+    }
+    if (method === "by reference template" && noteTypeCd) {
+      response = await dcof.OpenNewDocumentByReferenceTemplateIdAndNoteType(
+        patientId,
+        encounterId,
+        id,
+        noteTypeCd
+      );
+    }
+    retVal.success = Boolean(response);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retVal.inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return retVal;
+}
+
+// src/getValidEncountersAsync.ts
+async function getValidEncountersAsync(personId) {
+  const retData = {
+    inPowerChart: true,
+    encounterIds: []
+  };
+  try {
+    const dcof = await window.external.DiscernObjectFactory("PVCONTXTMPAGE");
+    const response = await dcof.GetValidEncounters(personId);
+    const eidStr = response.trim();
+    if (eidStr === "") return retData;
+    eidStr.split(",").forEach((e) => {
+      const eid = parseFloat(e);
+      if (isNaN(eid)) {
+        console.warn(
+          `getValidEncountersAsync: encounter ID ${e} could not be parsed to a number.`
+        );
+      } else {
+        retData.encounterIds.push(eid);
+      }
+    });
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/launchClinicalNoteAsync.ts
+var launchClinicalNoteAsync = async (patientId, encounterId, eventIds, opts) => {
+  const { viewOptionFlags, inheritanceProps, windowTitle } = opts || {};
+  const { viewName, viewSeq, compName, compSeq } = inheritanceProps || {};
+  let inPowerChart = true;
+  const params = [`${patientId}`, `${encounterId}`];
+  const _viewOptsFlags = !viewOptionFlags || viewOptionFlags.length === 0 ? ["view-only"] : viewOptionFlags;
+  params.push(`[${eventIds.join("|")}]`);
+  params.push(
+    `${windowTitle || `Clinical Note for patient with PID ${patientId} on encounter with EID ${encounterId}`}`
+  );
+  params.push(`${calculateViewOptionFlag(_viewOptsFlags)}`);
+  params.push(`${viewName || ""}`);
+  params.push(`${viewSeq || ""}`);
+  params.push(`${compName || ""}`);
+  params.push(`${compSeq || ""}`);
+  const eventString = `${params.join("|")}`;
+  try {
+    await window.external.MPAGES_EVENT("CLINICALNOTE", eventString);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      inPowerChart = false;
+      console.warn(`window.MPAGES_EVENT('CLINICALNOTE', '${eventString}')`);
+    } else {
+      throw e;
+    }
+  }
+  return { inPowerChart, eventString };
+};
+function calculateViewOptionFlag(viewOptionFlags) {
+  let total = 0;
+  viewOptionFlags.forEach((flag) => {
+    if (flag === "menu") total += 1;
+    if (flag === "buttons") total += 2;
+    if (flag === "toolbar") total += 4;
+    if (flag === "calculator") total += 8;
+    if (flag === "view-only") total += 16;
+  });
+  return total;
+}
+
+// src/launchDischargeProcessAsync.ts
+async function launchDischargeProcessAsync(patientId, encounterId, providerId) {
+  const retData = {
+    inPowerChart: true
+  };
+  try {
+    const dcof = await window.external.DiscernObjectFactory("DISCHARGEPROCESS");
+    dcof.person_id = patientId;
+    dcof.encounter_id = encounterId;
+    dcof.user_id = providerId;
+    dcof.LaunchDischargeDialog();
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/launchPatientEducationAsync.ts
+async function launchPatientEducationAsync(patientId, encounterId, targetTab) {
+  const retData = {
+    inPowerChart: true
+  };
+  try {
+    const dcof = await window.external.DiscernObjectFactory("PATIENTEDUCATION");
+    await dcof.SetPatient(patientId, encounterId);
+    await dcof.SetDefaultTab(targetTab === "instruction" ? 0 : 1);
+    await dcof.DoModal();
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      return {
+        inPowerChart: false
+      };
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/launchPowerFormAsync.ts
+var launchPowerFormAsync = async (target, patientId, encounterId, targetId) => {
+  const requiresTargetId = target === "new form" || target === "view form" || target === "modify form";
+  if (requiresTargetId && !targetId) {
+    throw new Error(
+      "'targetId' is required for all targets except 'new form search'."
+    );
+  }
+  const params = [`${patientId}`, `${encounterId}`];
+  switch (target) {
+    case "new form":
+      params.push(`${targetId}`);
+      params.push("0");
+      break;
+    case "view form":
+    case "modify form":
+      params.push("0");
+      params.push(`${targetId}`);
+      break;
+    case "new form search":
+      params.push("0");
+      params.push("0");
+      break;
+  }
+  params.push(target === "view form" ? "1" : "0");
+  const retData = {
+    eventString: `${params.join("|")}`,
+    inPowerChart: true
+  };
+  try {
+    await window.external.MPAGES_EVENT("POWERFORM", retData.eventString);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+      console.warn(
+        `window.MPAGES_EVENT('POWERFORM', '${retData.eventString}')`
+      );
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+};
+
+// src/launchPowerNoteAsync.ts
+var launchPowerNoteAsync = async (target, patientId, encounterId, targetId) => {
+  if (target === "new" && typeof targetId !== "string") {
+    throw new Error(
+      "targetId (for CKI) must be a string when launching a new PowerNote."
+    );
+  }
+  if (target === "existing" && typeof targetId !== "number") {
+    throw new Error(
+      "targetId must be a number when loading an existing PowerNote."
+    );
+  }
+  const params = [
+    `${patientId}`,
+    `${encounterId}`,
+    `${target === "new" ? targetId : ""}`,
+    `${target === "existing" ? targetId : 0}`
+  ];
+  const eventString = `${params.join("|")}`;
+  let inPowerChart = true;
+  try {
+    await window.external.MPAGES_EVENT("POWERNOTE", eventString);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      inPowerChart = false;
+      console.warn(`window.MPAGES_EVENT('POWERNOTE', '${eventString}')`);
+    } else {
+      throw e;
+    }
+  }
+  return { eventString, inPowerChart };
+};
+
+// src/manageAppointmentAsync.ts
+async function manageAppointmentAsync(action, eventId) {
+  let actionSuccess = 0;
+  let inPowerChart = true;
+  try {
+    const dcof = await window.external.DiscernObjectFactory(
+      "PEXSCHEDULINGACTIONS"
+    );
+    switch (action) {
+      case "check in":
+        actionSuccess = await dcof.CheckInAppointment(eventId);
+        break;
+      case "check out":
+        actionSuccess = await dcof.CheckOutAppointment(eventId);
+        break;
+      case "cancel":
+        actionSuccess = await dcof.CancelAppointment(eventId);
+        break;
+      case "no show":
+        actionSuccess = await dcof.NoShowAppointment(eventId);
+        break;
+      case "view appt dialog":
+        actionSuccess = await dcof.ShowView(eventId);
+        break;
+      case "view appt history":
+        actionSuccess = await dcof.ShowHistoryView(eventId);
+        break;
+      default:
+        throw new Error("Invalid appointment action");
+    }
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return {
+    success: actionSuccess === 1,
+    inPowerChart
+  };
+}
+
+// src/openApplicationAsync.ts
+async function openApplicationAsync(mode, target, args) {
+  const retVal = {
+    inPowerChart: true,
+    eventString: "",
+    badInput: false
+  };
+  if (mode === "by solution name" && !args) {
+    throw new Error(
+      "openApplicationAsync: 'by solution name' mode requires arguments"
+    );
+  }
+  if (mode === "by application object" && !args) {
+    throw new Error(
+      "openApplicationAsync: 'by application object' mode requires arguments"
+    );
+  }
+  const argString = generateOpenApplicationArgumentString(args || []);
+  const modeValue = modeMap.get(mode);
+  if (modeValue === void 0) {
+    throw new Error("openApplicationAsync: invalid mode");
+  }
+  retVal.eventString = argString;
+  try {
+    const response = await window.APPLINK(modeValue, target, argString);
+    retVal.badInput = response === null ? true : false;
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retVal.inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return retVal;
+}
+function generateOpenApplicationArgumentString(args) {
+  return args.map(({ argument: arg, value, quickOpen: qo }) => {
+    const isOrgLevel = /organizertab/i.test(arg);
+    const isTab = /firsttab/i.test(arg) || /organizertab/i.test(arg);
+    const quickOpen = qo;
+    const quickOpenStr = quickOpen && isTab && !isOrgLevel ? "+" : "";
+    const surroundStr = isTab ? "^" : "";
+    return `/${arg}=${surroundStr}${value}${quickOpenStr}${surroundStr}`;
+  }).join(" ").toUpperCase();
+}
+var modeMap = /* @__PURE__ */ new Map();
+modeMap.set("by solution name", 0);
+modeMap.set("by application object", 1);
+modeMap.set("by file", 100);
+modeMap.set("by url", 100);
+modeMap.set("by executable", 100);
+
+// src/openOrganizerTabAsync.ts
+async function openOrganizerTabAsync(tab) {
+  const args = [
+    {
+      argument: "ORGANIZERTAB",
+      value: tab
+    }
+  ];
+  return await openApplicationAsync("by executable", "Powerchart.exe", args);
+}
+
+// src/openPatientTabAsync.ts
+async function openPatientTabAsync(patientId, encounterId, tab, quickOpen) {
+  const args = [
+    {
+      argument: "PERSONID",
+      value: patientId
+    },
+    {
+      argument: "ENCNTRID",
+      value: encounterId
+    },
+    {
+      argument: "FIRSTTAB",
+      value: tab,
+      quickOpen
+    }
+  ];
+  return await openApplicationAsync("by executable", "$APP_APPNAME$", args);
+}
+
+// src/openWebsiteByUrlAsync.ts
+async function openWebsiteByUrlAsync(url) {
+  if (!url.toLowerCase().includes("http://") && !url.toLowerCase().includes("https://")) {
+    throw new Error(
+      "openWebsiteByUrlAsync: URL must include the protocol 'http://' or 'https://'"
+    );
+  }
+  return await openApplicationAsync("by url", url);
+}
+
+// src/submitOrdersAsync.ts
+var import_fast_xml_parser = require("fast-xml-parser");
+
+// src/utils/createOrderString.ts
+var _createOrderString = (action, id, opts) => {
+  const { orderSentenceId, nomenclatureIds, origination, interactionCheck } = opts || {};
+  let params = [orderActionMap.get(action)];
+  const nids = nomenclatureIds || [];
+  switch (action) {
+    case "launch moew":
+      params = params.concat(["0", "0", "0", "0", "0"]);
+      break;
+    case "new order":
+      if (!id)
+        throw new Error(
+          `id (as synonym ID) is required for the '${action}' action`
+        );
+      params = params.concat([
+        `${id}`,
+        `${originationMap.get(origination) || 0}`,
+        `${orderSentenceId || 0}`,
+        nids.length > 1 ? `[${nids.join("|")}]` : `${nids[0] || 0}`,
+        `${interactionMap.get(interactionCheck) || 0}`
+      ]);
+      break;
+    default:
+      if (!id)
+        throw new Error(
+          `id (as the existing order ID) is required for the '${action}' action`
+        );
+      params = params.concat([`${id}`]);
+      break;
+  }
+  return `{${params.join("|")}}`;
+};
+var orderActionMap = (/* @__PURE__ */ new Map()).set("launch moew", "ORDER").set("activate existing", "ACTIVATE").set("cancel-discontinue", "CANCEL DC").set("cancel-reorder", "CANCEL REORD").set("clear actions", "CLEAR").set("convert inpatient", "CONVERT_INPAT").set("convert prescription", "CONVERT_RX").set("modify", "MODIFY").set("new order", "ORDER").set("renew", "RENEW").set("renew prescription", "RENEW_RX").set("copy existing", "REPEAT").set("resume", "RESUME").set("suspend", "SUSPEND");
+var originationMap = (/* @__PURE__ */ new Map()).set("satellite", "5").set("prescription", "1").set("normal", "0");
+var interactionMap = (/* @__PURE__ */ new Map()).set("on sign", "1").set("default", "0");
+var createOrderString = (action, id, opts) => _createOrderString(action, id, opts);
+var LAUNCH_MOEW_ORDER_STRING = _createOrderString("launch moew");
+
+// src/submitOrdersAsync.ts
+var launchViewMap = (/* @__PURE__ */ new Map()).set("search", 8).set("profile", 16).set("signature", 32);
+var tabsMap = (/* @__PURE__ */ new Map()).set("orders", { tab: 2, display: 0 }).set("power orders", { tab: 2, display: 127 }).set("medications", { tab: 3, display: 0 }).set("power medications", { tab: 3, display: 127 });
+var submitOrdersAsync = async (patientId, encounterId, orders, opts) => {
+  let { targetTab, launchView, signSilently, dryRun } = opts || {};
+  if (!targetTab) targetTab = "orders";
+  if (!launchView) launchView = "signature";
+  const enablePowerPlans = targetTab === "power orders" || targetTab === "power medications";
+  const s = orders.map(
+    ({ action, id, opts: opts2 }) => createOrderString(action, id, opts2)
+  );
+  let params = [`${patientId}`, `${encounterId}`, s.join("")];
+  params.push(enablePowerPlans ? "24" : "0");
+  const { tab, display } = tabsMap.get(targetTab) || { tab: 2, display: 127 };
+  params.push(`{${tab}|${display}}`);
+  params.push(`${launchViewMap.get(launchView) || 32}`);
+  params.push(`${signSilently ? "1" : "0"}`);
+  const eventString = params.join("|");
+  const retVal = {
+    eventString,
+    inPowerChart: true,
+    status: "success",
+    response: null,
+    ordersPlaced: null
+  };
+  if (dryRun) {
+    retVal.status = "dry run";
+    return retVal;
+  }
+  try {
+    const response = await window.external.MPAGES_EVENT(
+      "ORDERS",
+      eventString
+    );
+    if (response === null) {
+      retVal.status = "failed";
+      return retVal;
+    }
+    if (typeof response !== "string") {
+      retVal.status = "invalid data returned";
+      return retVal;
+    }
+    switch (response.trim()) {
+      case "":
+        retVal.status = "cancelled";
+        break;
+      default:
+        retVal.status = "success";
+        const parser = new import_fast_xml_parser.XMLParser();
+        try {
+          const parsed = parser.parse(response);
+          retVal.response = parsed;
+          if (!(parsed.Orders.Order instanceof Array)) {
+            parsed.Orders.Order = [parsed.Orders.Order];
+          }
+          retVal.ordersPlaced = parsed.Orders.Order.map((o) => ({
+            name: o.OrderedAsMnemonic,
+            oid: o.OrderId,
+            display: o.ClinDisplayLine
+          }));
+        } catch {
+          retVal.status = "xml parse error";
+        }
+        break;
+    }
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retVal.inPowerChart = false;
+      retVal.status = "invalid data returned";
+      warnAttemptedOrdersOutsideOfPowerChart(eventString);
+    } else {
+      throw e;
+    }
+  }
+  return retVal;
+};
+
+// src/utils/calculateMOEWBitmask.ts
+var calculateMOEWBitmask = (targetTab, inputFlags) => {
+  let dwCustomizeFlag = 0;
+  let dwTabFlag = 0;
+  let dwTabDisplayOptionsFlag = 0;
+  if (targetTab === "orders tab") {
+    dwTabFlag = 2;
+  }
+  if (targetTab === "medications tab") {
+    dwTabFlag = 3;
+  }
+  const defaultOpts = [
+    "show refresh and print buttons",
+    "allow power plan doc",
+    "allow power plans",
+    "show list details",
+    "show scratchpad",
+    "show order profile",
+    "show orders search",
+    "show related res",
+    "show diag and probs",
+    "show nav tree",
+    "show demographics",
+    "show med rec"
+  ];
+  const userFlags = !inputFlags || inputFlags.length === 0 ? defaultOpts : inputFlags;
+  const cernerFlags = [];
+  userFlags.forEach((flag) => {
+    if (flag === "show demographics") {
+      return;
+    }
+    if (flag === "show med rec") {
+      return;
+    }
+    return cernerFlags.push(flag);
+  });
+  if (!userFlags.includes("show demographics")) {
+    cernerFlags.push("hide demographics");
+  }
+  if (!userFlags.includes("show med rec")) {
+    cernerFlags.push("hide med rec");
+  }
+  cernerFlags.forEach((option) => {
+    switch (option) {
+      // Calculate the dwCustomizeFlagParamater
+      case "sign later":
+        dwCustomizeFlag += 1;
+        break;
+      case "read only":
+        dwCustomizeFlag += 4;
+        break;
+      case "allow power plans":
+        dwCustomizeFlag += 8;
+        break;
+      case "allow power plan doc":
+        dwCustomizeFlag += 16;
+        break;
+      case "allow only inpatient and outpatient orders":
+        dwCustomizeFlag += 32;
+        break;
+      case "show refresh and print buttons":
+        dwCustomizeFlag += 128;
+        break;
+      case "documented meds only":
+        dwCustomizeFlag += 256;
+        break;
+      case "hide med rec":
+        dwCustomizeFlag += 512;
+        break;
+      case "disallow EOL":
+        dwCustomizeFlag += 1024;
+        break;
+      case "hide demographics":
+        dwCustomizeFlag += 2048;
+        break;
+      case "add rx to filter":
+        dwCustomizeFlag += 4096;
+        break;
+      case "disable auto search":
+        dwCustomizeFlag += 8192;
+        break;
+      case "allow regimen":
+        dwCustomizeFlag += 16384;
+        break;
+      // Calculate the dwTabDisplayOptionsFlag parameter
+      case "show nav tree":
+        dwTabDisplayOptionsFlag += 1;
+        break;
+      case "show diag and probs":
+        dwTabDisplayOptionsFlag += 2;
+        break;
+      case "show related res":
+        dwTabDisplayOptionsFlag += 4;
+        break;
+      case "show orders search":
+        dwTabDisplayOptionsFlag += 8;
+        break;
+      case "show order profile":
+        dwTabDisplayOptionsFlag += 16;
+        break;
+      case "show scratchpad":
+        dwTabDisplayOptionsFlag += 32;
+        break;
+      case "show list details":
+        dwTabDisplayOptionsFlag += 64;
+        break;
+    }
+  });
+  return {
+    dwCustomizeFlag,
+    dwTabFlag,
+    dwTabDisplayOptionsFlag
+  };
+};
+
+// src/utils/addNewOrdersToScratchPadAsync.ts
+async function addNewOrdersToScratchpadAsync(dcof, moewHandle, standaloneOrders, interactionChecking) {
+  let retData = {
+    inPowerChart: true,
+    result: "successfully added"
+  };
+  if (standaloneOrders.length < 1) {
+    throw new RangeError(
+      "There should be at least one standalone order provided."
+    );
+  }
+  let standaloneOrdersXML = "";
+  standaloneOrders.forEach((standaloneOrder) => {
+    standaloneOrdersXML += `<Order><EOrderOriginationFlag>${standaloneOrder.origination === "inpatient order" ? 0 : 1}</EOrderOriginationFlag><SynonymId>${standaloneOrder.synonymId}</SynonymId>
+    <OrderSentenceId>${standaloneOrder.sentenceId ? standaloneOrder.sentenceId : ""}</OrderSentenceId></Order>`;
+  });
+  standaloneOrdersXML = "<Orders>" + standaloneOrdersXML;
+  standaloneOrdersXML += "</Orders>";
+  standaloneOrdersXML = standaloneOrdersXML.replace(/[\r\n\s]/g, "");
+  try {
+    const response = await dcof.AddNewOrdersToScratchpad(
+      moewHandle,
+      standaloneOrdersXML,
+      interactionChecking
+    );
+    switch (response) {
+      case 0:
+        retData.result = "successfully added";
+        break;
+      case 1:
+        retData.result = "added and signed";
+        break;
+      case 2:
+        retData.result = "cancelled by user";
+        break;
+      case 3:
+        retData.result = "add failed";
+        break;
+    }
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+      retData.result = "add failed";
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/utils/addPowerPlanWithDetailsAsync.ts
+async function addPowerPlanWithDetailsAsync(dcof, moewHandle, powerPlanOrders) {
+  let retData = {
+    inPowerChart: true,
+    powerPlansAdded: true
+  };
+  if (powerPlanOrders.length < 1) {
+    throw new RangeError(
+      "There should be at least one PowerPlan order provided."
+    );
+  }
+  let powerPlanOrdersXML = "";
+  powerPlanOrders.forEach(
+    ({
+      pathwayCatalogId: cid,
+      personalizedPlanId: pid,
+      diagnosisIds: dids
+    }) => {
+      powerPlanOrdersXML += `<Plan><PathwayCatalogId>${cid}</PathwayCatalogId><PersonalizedPlanId>${pid ? pid : ""}</PersonalizedPlanId><Diagnoses>
+    ${dids ? dids.map((diagnosisSynonymID) => {
+        return "<DiagnosisId>" + diagnosisSynonymID + "</DiagnosisId>";
+      }) : ""}
+    </Diagnoses></Plan>`;
+    }
+  );
+  powerPlanOrdersXML = "<Plans>" + powerPlanOrdersXML;
+  powerPlanOrdersXML += "</Plans>";
+  powerPlanOrdersXML = powerPlanOrdersXML.replace(/[\r\n\s]/g, "");
+  try {
+    const response = await dcof.AddPowerPlanWithDetails(
+      moewHandle,
+      powerPlanOrdersXML
+    );
+    retData.powerPlansAdded = response === 0 ? false : true;
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+      retData.powerPlansAdded = false;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/utils/createMOEWAsync.ts
+async function createMOEWAsync(dcof, personId, encounterId, dwCustomizeFlag, dwTabFlag, dwTabDisplayOptionsFlag) {
+  let retData = {
+    inPowerChart: true,
+    moewHandle: null
+  };
+  try {
+    const response = await dcof.CreateMOEW(
+      personId,
+      encounterId,
+      dwCustomizeFlag,
+      dwTabFlag,
+      dwTabDisplayOptionsFlag
+    );
+    retData.moewHandle = response === 0 ? null : response;
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+      retData.moewHandle = null;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/utils/destroyMOEWAsync.ts
+async function destroyMOEWAsync(dcof, moewHandle) {
+  let retData = {
+    inPowerChart: true
+  };
+  try {
+    const response = await dcof.DestroyMOEW(moewHandle);
+    console.log("Response from DestroyMOEW() is: ", response);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/utils/displayMOEWAsync.ts
+async function displayMOEWAsync(dcof, moewHandle) {
+  let retData = {
+    inPowerChart: true,
+    signed: false
+  };
+  try {
+    const response = await dcof.DisplayMOEW(moewHandle);
+    retData.signed = Boolean(response);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/utils/getOrdersPlacedAsync.ts
+var import_fast_xml_parser2 = require("fast-xml-parser");
+async function getOrdersPlacedAsync(dcof, moewHandle) {
+  let retData = {
+    inPowerChart: true,
+    ordersPlaced: [],
+    parsedXML: null,
+    rawXML: "",
+    status: "success"
+  };
+  try {
+    retData.rawXML = await dcof.GetXMLOrdersMOEW(moewHandle);
+    if (typeof retData.rawXML !== "string") {
+      retData.status = "invalid data returned";
+      return retData;
+    }
+    if (retData.rawXML.trim() === "") {
+      retData.status = "cancelled, failed, or invalid parameters provided";
+      return retData;
+    }
+    const parser = new import_fast_xml_parser2.XMLParser();
+    try {
+      const parsed = parser.parse(retData.rawXML);
+      retData.parsedXML = parsed;
+      if (!(parsed.Orders.Order instanceof Array)) {
+        parsed.Orders.Order = [parsed.Orders.Order];
+      }
+      retData.ordersPlaced = parsed.Orders.Order.map((o) => ({
+        name: o.OrderedAsMnemonic,
+        oid: o.OrderId,
+        display: o.ClinDisplayLine
+      }));
+    } catch {
+      retData.status = "xml parse error";
+    }
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+      retData.parsedXML = null;
+      retData.ordersPlaced = [];
+      retData.rawXML = "";
+      retData.status = "dry run";
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/utils/signOrdersAsync.ts
+async function signOrdersAsync(dcof, moewHandle) {
+  let retData = {
+    inPowerChart: true
+  };
+  try {
+    const response = await dcof.SignOrders(moewHandle);
+    console.log("Response from SignMOEW() is: ", response);
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+}
+
+// src/submitPowerOrdersAsync.ts
+var submitPowerOrdersAsync = async (patientId, encounterId, orders, opts, moewFlags, targetTab) => {
+  opts = !opts ? { signSilently: false, interactionChecking: true } : opts;
+  moewFlags = !moewFlags ? [] : moewFlags;
+  const {
+    dwCustomizeFlag,
+    dwTabFlag,
+    dwTabDisplayOptionsFlag
+  } = calculateMOEWBitmask(targetTab || "orders tab", moewFlags);
+  let retData = {
+    inPowerChart: true,
+    status: "success",
+    ordersPlaced: null
+  };
+  if (orders.length < 1) {
+    throw new Error(
+      "At least one order to submit must be provided to this function."
+    );
+  }
+  let powerPlanOrders = [];
+  let standaloneOrders = [];
+  orders.forEach((order) => {
+    if (isPowerPlanOrder(order)) {
+      powerPlanOrders.push(order);
+    } else if (isStandaloneOrder(order)) {
+      standaloneOrders.push(order);
+    } else {
+      throw new SyntaxError(
+        "Each order provided must be of either a PowerPlanOrder or  StandaloneOrder type."
+      );
+    }
+  });
+  try {
+    let moewId = 0;
+    const dcof = await window.external.DiscernObjectFactory("POWERORDERS");
+    const createMOEW = await createMOEWAsync(
+      dcof,
+      patientId,
+      encounterId,
+      dwCustomizeFlag,
+      dwTabFlag,
+      dwTabDisplayOptionsFlag
+    );
+    if (createMOEW.inPowerChart === false) {
+      retData.inPowerChart = false;
+      retData.ordersPlaced = null;
+      retData.status = "dry run";
+      return retData;
+    }
+    if (createMOEW.moewHandle === null) {
+      retData.inPowerChart = true;
+      retData.ordersPlaced = null;
+      retData.status = "invalid data returned";
+      return retData;
+    }
+    moewId = createMOEW.moewHandle;
+    if (powerPlanOrders && powerPlanOrders.length >= 1) {
+      const addPowerPlans = await addPowerPlanWithDetailsAsync(
+        dcof,
+        moewId,
+        powerPlanOrders
+      );
+      if (addPowerPlans.inPowerChart === false) {
+        retData.inPowerChart = false;
+        retData.ordersPlaced = null;
+        retData.status = "dry run";
+        return retData;
+      }
+      if (addPowerPlans.powerPlansAdded === false) {
+        retData.inPowerChart = true;
+        retData.ordersPlaced = null;
+        retData.status = "cancelled, failed, or invalid parameters provided";
+        return retData;
+      }
+    }
+    if (standaloneOrders && standaloneOrders.length >= 1) {
+      const addStandaloneOrders = await addNewOrdersToScratchpadAsync(
+        dcof,
+        moewId,
+        standaloneOrders,
+        opts.interactionChecking
+      );
+      if (addStandaloneOrders.inPowerChart === false) {
+        retData.inPowerChart = false;
+        retData.ordersPlaced = null;
+        retData.status = "dry run";
+        return retData;
+      }
+      if (addStandaloneOrders.result === "add failed" || addStandaloneOrders.result === "cancelled by user") {
+        retData.inPowerChart = true;
+        retData.ordersPlaced = null;
+        retData.status = "cancelled, failed, or invalid parameters provided";
+        return retData;
+      }
+    }
+    if (opts.signSilently) {
+      const signOrders = await signOrdersAsync(dcof, moewId);
+      if (signOrders.inPowerChart === false) {
+        retData.inPowerChart = false;
+        retData.ordersPlaced = null;
+        retData.status = "dry run";
+        return retData;
+      }
+    } else {
+      const displayMOEW = await displayMOEWAsync(dcof, moewId);
+      if (displayMOEW.inPowerChart === false) {
+        retData.inPowerChart = false;
+        retData.ordersPlaced = null;
+        retData.status = "dry run";
+        return retData;
+      }
+    }
+    const getPlacedOrders = await getOrdersPlacedAsync(dcof, moewId);
+    if (getPlacedOrders.inPowerChart === false) {
+      retData.inPowerChart = false;
+      retData.ordersPlaced = null;
+      retData.status = "dry run";
+      return retData;
+    }
+    if (getPlacedOrders.ordersPlaced === null || getPlacedOrders.ordersPlaced.length === 0) {
+      retData.inPowerChart = true;
+      retData.ordersPlaced = null;
+      retData.status = getPlacedOrders.status;
+      return retData;
+    }
+    retData.inPowerChart = true;
+    retData.ordersPlaced = getPlacedOrders.ordersPlaced;
+    retData.status = getPlacedOrders.status;
+    const destroyMOEW = await destroyMOEWAsync(dcof, moewId);
+    if (destroyMOEW.inPowerChart === false) {
+      retData.inPowerChart = false;
+      retData.ordersPlaced = null;
+      retData.status = "dry run";
+      return retData;
+    }
+  } catch (e) {
+    if (outsideOfPowerChartError(e)) {
+      retData.inPowerChart = false;
+      retData.ordersPlaced = null;
+      retData.status = "dry run";
+      return retData;
+    } else {
+      throw e;
+    }
+  }
+  return retData;
+};
+var isPowerPlanOrder = (o) => {
+  return o.hasOwnProperty("pathwayCatalogId");
+};
+var isStandaloneOrder = (o) => {
+  return o.hasOwnProperty("synonymId") && o.hasOwnProperty("origination");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CclCallParam,
+  CclRequestResponse,
+  XmlCclReadyState,
+  XmlCclResult,
+  addAddendumToDocumentAsync,
+  createNewDocumentAsync,
+  getValidEncountersAsync,
+  launchClinicalNoteAsync,
+  launchDischargeProcessAsync,
+  launchPatientEducationAsync,
+  launchPowerFormAsync,
+  launchPowerNoteAsync,
+  makeCclRequestAsync,
+  manageAppointmentAsync,
+  openApplicationAsync,
+  openOrganizerTabAsync,
+  openPatientTabAsync,
+  openWebsiteByUrlAsync,
+  submitOrdersAsync,
+  submitPowerOrdersAsync
+});
+//# sourceMappingURL=index.cjs.map