@overmap-ai/core 1.0.53-fix-outbox.0 → 1.0.53-fix-outbox.1

package/dist/overmap-core.js

@@ -10,7 +10,6 @@ import React__default, { useState, useEffect, useRef, memo, useMemo, useCallback
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { unsafeShowToast, AlertDialogProvider, ToastProvider, DefaultTheme, Flex as Flex$1, IconButton, RiIcon, Text as Text$1, useSeverityColor, TextArea, Select, useToast, Badge, MultiSelect, Overlay, Button, Spinner, useViewportSize, ButtonGroup, IconColorUtility, Tooltip, Popover, useSize, ToggleButton, Separator, OvermapItem, ButtonList, divButtonProps, OvermapDropdownMenu, Checkbox as Checkbox$1, Input, useAlertDialog } from "@overmap-ai/blocks";
 import { DepGraph } from "dependency-graph";
-import saveAs$1, { saveAs } from "file-saver";
 import { offline as offline$1 } from "@redux-offline/redux-offline";
 import offlineConfig from "@redux-offline/redux-offline/lib/defaults";
 import localforage from "localforage";
@@ -18,6 +17,7 @@ import createMigration from "redux-persist-migrate";
 import { createSlice, createSelector, combineReducers, configureStore, createNextState } from "@reduxjs/toolkit";
 import request from "superagent";
 import { shallowEqual as shallowEqual$1, useDispatch, useSelector } from "react-redux";
+import saveAs$1, { saveAs } from "file-saver";
 import { v4 } from "uuid";
 import ColorCls from "color";
 import jwtDecode from "jwt-decode";
@@ -36,354 +36,6 @@ import "react-pdf/dist/Page/TextLayer.css";
 import { ReactSketchCanvas } from "react-sketch-canvas";
 import set from "lodash.set";
 import cloneDeep from "lodash.clonedeep";
-class OutboxCoordinator {
-  constructor() {
-    __publicField(this, "graph");
-    __publicField(this, "requestAttemptCounter");
-    this.graph = new DepGraph();
-    this.requestAttemptCounter = {};
-  }
-  /**
-   * Used when the app is loaded. Reconstructs the dependency graph based on an outbox from the redux-offline store.
-   */
-  static fromOutbox(outbox) {
-    const ret = new OutboxCoordinator();
-    for (let i = 0; i < outbox.length; i++) {
-      const outboxItem = outbox[i];
-      if (!outboxItem) {
-        console.error("Outbox item was undefined");
-        continue;
-      }
-      ret.sneakRequest(outboxItem);
-      for (let j = 0; j < i; j++) {
-        const previousOutboxItem = outbox[j];
-        if (!previousOutboxItem) {
-          console.error("Previous outbox item was undefined");
-          continue;
-        }
-        if (previousOutboxItem.payload.uuid === outboxItem.payload.uuid) {
-          continue;
-        }
-        if (previousOutboxItem.payload.blocks.some((block) => outboxItem.payload.blockers.includes(block))) {
-          OutboxCoordinator._addDependency(
-            outboxItem.payload.uuid,
-            previousOutboxItem.payload.uuid,
-            ret.graph
-          );
-        }
-      }
-    }
-    return ret;
-  }
-  _addDependency(from, to) {
-    OutboxCoordinator._addDependency(from, to, this.graph);
-  }
-  static _addDependency(from, to, graph) {
-    if (from === to) {
-      throw new Error(`Tried to add dependency from node to itself: ${from}`);
-    }
-    const fromExists = graph.hasNode(from);
-    if (!fromExists) {
-      throw new Error(`Tried to add dependency from non-existent node: ${from} (to node: ${to})`);
-    }
-    const toExists = graph.hasNode(to);
-    if (!toExists) {
-      throw new Error(`Tried to add dependency to non-existent node: ${to} (from node: ${from})`);
-    }
-    graph.addDependency(from, to);
-  }
-  /**
-   * If there are one or more nodes in the graph, we find all nodes that match a dependency of the request and add a
-   * dependency from the new request node to that node.
-   */
-  addRequest(request2) {
-    this.graph.addNode(request2.payload.uuid, request2);
-    if (request2.payload.blockers.length === 0 || this.graph.size() === 1) {
-      return;
-    }
-    for (const node of this.graph.overallOrder()) {
-      if (node === request2.payload.uuid)
-        continue;
-      const details = this.graph.getNodeData(node);
-      if (request2.payload.blockers.some((blocker) => details.payload.blocks.includes(blocker))) {
-        this._addDependency(request2.payload.uuid, node);
-      }
-    }
-  }
-  /**
-   * Inserts a request at the beginning of the queue. This could be used for requests that were popped, then failed,
-   * and need to be re-enqueued at the front of the queue. Any requests that were previously blocked by this request
-   * will be blocked by this request again. No blockers will be added to this request because it is assumed that the
-   * request was already unblocked when it was popped.
-   * @param request The request to insert at the beginning of the queue.
-   */
-  insertRequest(request2) {
-    this.graph.addNode(request2.payload.uuid, request2);
-    for (const node of this.graph.overallOrder()) {
-      if (node === request2.payload.uuid)
-        continue;
-      const details = this.graph.getNodeData(node);
-      if (details.payload.blockers.some((blocker) => request2.payload.blocks.includes(blocker))) {
-        this._addDependency(node, request2.payload.uuid);
-      }
-    }
-  }
-  /**
-   * Sneaks a request into the dependency graph without creating any blockers. Useful for reconstructing the graph
-   * (from the offline store's outbox state) when the app is loaded.
-   */
-  sneakRequest(request2) {
-    this.graph.addNode(request2.payload.uuid, request2);
-  }
-  /**
-   * Returns the next node in line to be sent. This is the unblocked node with the fewest number of attempts. If there
-   * are multiple nodes with the same number of attempts, the first one (by insertion order) will be returned.
-   */
-  _getNextNode() {
-    const leafNodes = this.graph.overallOrder(true);
-    let minAttempts = Infinity;
-    let minAttemptsNode;
-    for (const node of leafNodes) {
-      const attempts = this.requestAttemptCounter[node] || 0;
-      if (attempts < minAttempts) {
-        minAttempts = attempts;
-        minAttemptsNode = node;
-      }
-    }
-    return minAttemptsNode;
-  }
-  /**
-   * Returns the next request in line to be sent without removing it.
-   */
-  peek() {
-    const nextNode = this._getNextNode();
-    if (!nextNode)
-      return void 0;
-    return this.graph.getNodeData(nextNode);
-  }
-  /**
-   * Removes a request from the graph. This should be called when a request is successfully sent.
-   * @param uuid The UUID of the request to remove.
-   */
-  remove(uuid) {
-    this.graph.removeNode(uuid);
-    delete this.requestAttemptCounter[uuid];
-  }
-  /**
-   * Returns the next request in line to be sent and removes it from the graph.
-   */
-  pop() {
-    const nextRequestDetails = this.peek();
-    if (nextRequestDetails) {
-      this.graph.removeNode(nextRequestDetails.payload.uuid);
-    }
-    return nextRequestDetails;
-  }
-  /**
-   * Gets the current queue for the outbox. Should be called to get a new value for the outbox slice every time a
-   * request is enqueued. It will be used to render the outbox items in a single lane.
-   */
-  getQueue() {
-    const ret = this.graph.overallOrder().map((nodeName) => this.graph.getNodeData(nodeName));
-    const nextNode = this._getNextNode();
-    if (nextNode) {
-      const nextRequestDetails = this.graph.getNodeData(nextNode);
-      const nextRequestIndex = ret.findIndex(
-        (request2) => request2.payload.uuid === nextRequestDetails.payload.uuid
-      );
-      if (nextRequestIndex !== -1) {
-        ret.splice(nextRequestIndex, 1);
-        ret.unshift(nextRequestDetails);
-      }
-    }
-    return ret;
-  }
-  /**
-   * Gets a list of requests that can currently be sent (requests with no unresolved dependencies). Used to process
-   * the next ready request in case the request at the front of the queue is failing.
-   */
-  getReady() {
-    let ret = this.graph.overallOrder(true).map((nodeName) => this.graph.getNodeData(nodeName));
-    ret = ret.sort((a, b) => {
-      return a.meta.offline.effect.timestamp.localeCompare(b.meta.offline.effect.timestamp);
-    });
-    ret = ret.sort((a, b) => {
-      const aAttempts = this.requestAttemptCounter[a.payload.uuid] || 0;
-      const bAttempts = this.requestAttemptCounter[b.payload.uuid] || 0;
-      return aAttempts - bAttempts;
-    });
-    return ret;
-  }
-  registerRetry(uuid) {
-    this.requestAttemptCounter[uuid] = (this.requestAttemptCounter[uuid] || 0) + 1;
-  }
-}
-const UNKNOWN_ERROR_MESSAGE = "An unknown error occurred";
-const MAX_ERROR_MESSAGE_LENGTH = 500;
-const _SPECIAL_KEYS = ["non_field_errors", "detail"];
-function extractErrorMessage(errorRes, err) {
-  let ret;
-  if (errorRes == null ? void 0 : errorRes.body) {
-    if (typeof errorRes.body === "object") {
-      const responseBody = errorRes.body;
-      if (typeof responseBody.error === "string") {
-        ret = responseBody.error;
-      } else if (typeof responseBody.message === "string") {
-        ret = responseBody.message;
-      } else if (responseBody.body) {
-        try {
-          ret = Object.entries(responseBody.body).map(([key, value]) => {
-            if (typeof value === "string") {
-              if (_SPECIAL_KEYS.includes(key))
-                return value;
-              return `${key}: ${value}`;
-            }
-            if (Array.isArray(value)) {
-              if (_SPECIAL_KEYS.includes(key))
-                return value.join("\n");
-              return value.map((v) => `${key}: ${v}`).join("\n");
-            }
-            return `${key}: ${JSON.stringify(value)}`;
-          }).join("\n");
-        } catch (e) {
-          console.error("Failed to extract error message from response body", e);
-        }
-      }
-    } else if (typeof errorRes.body === "string") {
-      ret = errorRes.body;
-    }
-  } else if (errorRes == null ? void 0 : errorRes.text) {
-    ret = errorRes.text;
-  } else if (err instanceof Error) {
-    ret = err.message;
-  }
-  if (!ret || ret.length > MAX_ERROR_MESSAGE_LENGTH) {
-    return UNKNOWN_ERROR_MESSAGE;
-  }
-  return ret;
-}
-class APIError extends Error {
-  constructor(options) {
-    super(UNKNOWN_ERROR_MESSAGE);
-    // NOTE: Needs to conform to NetworkError in @redux-offline/redux-offline, which has `status` and `response`.
-    __publicField(this, "status");
-    __publicField(this, "response");
-    __publicField(this, "message");
-    __publicField(this, "options");
-    const { response, innerError } = options;
-    this.message = options.message ?? extractErrorMessage(response, innerError) ?? UNKNOWN_ERROR_MESSAGE;
-    this.status = (response == null ? void 0 : response.status) ?? 0;
-    this.response = response;
-    options.discard = options.discard ?? false;
-    this.options = options;
-  }
-}
-class BaseApiService {
-  constructor(sdk) {
-    __publicField(this, "client");
-    this.client = sdk;
-  }
-}
-function hex(buffer) {
-  const hashArray = new Uint8Array(buffer);
-  return hashArray.reduce((data, byte) => data + byte.toString(16).padStart(2, "0"), "");
-}
-const getFileS3Key = async (file, hash) => {
-  if (!hash) {
-    hash = await hashFile(file);
-  }
-  let fileType = file.type;
-  if (fileType.includes("/")) {
-    fileType = fileType.split("/")[1];
-  }
-  if (!fileType) {
-    throw new Error(`Could not extract file type from ${file.type}`);
-  }
-  return `${hash}.${fileType}`;
-};
-function hashFile(file) {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => {
-      const fileResult = reader.result;
-      if (!fileResult) {
-        reject();
-        return;
-      }
-      void crypto.subtle.digest("SHA-1", fileResult).then((hash) => {
-        const sha1result = hex(hash);
-        resolve(sha1result);
-      });
-    };
-    reader.readAsArrayBuffer(file);
-  });
-}
-function getFileIdentifier(file) {
-  if (!file.name || !file.type || !file.size) {
-    const message = "File has no name, type, and/or size";
-    console.error(`${message}`, file);
-    throw new Error(`${message}.`);
-  }
-  return `${file.name}&${file.type}${file.size}`;
-}
-function getRenamedFile(file, newName) {
-  return new File([file], newName, { type: file.type });
-}
-function downloadInMemoryFile(filename, text) {
-  const element = document.createElement("a");
-  element.setAttribute("href", "data:text/plain;charset=utf-8," + encodeURIComponent(text));
-  element.setAttribute("download", filename);
-  element.style.display = "none";
-  document.body.appendChild(element);
-  element.click();
-  document.body.removeChild(element);
-}
-const constructUploadedFilePayloads = async (files) => {
-  const filePayloads = {};
-  for (const file of files) {
-    const sha1 = await hashFile(file);
-    filePayloads[sha1] = {
-      sha1,
-      extension: file.name.split(".").pop() || "",
-      file_type: file.type,
-      size: file.size
-    };
-  }
-  return Object.values(filePayloads);
-};
-const fileToBlob = async (dataUrl) => {
-  return (await fetch(dataUrl)).blob();
-};
-const blobToBase64 = (blob) => {
-  return new Promise((resolve, _) => {
-    const reader = new FileReader();
-    reader.onloadend = () => {
-      var _a2;
-      resolve(((_a2 = reader.result) == null ? void 0 : _a2.toString()) || "");
-    };
-    reader.readAsDataURL(blob);
-  });
-};
-const useFileSrc = (props) => {
-  const { file, fileSha1, placeholder } = props;
-  const [src, setSrc] = useState(placeholder);
-  const { sdk } = useSDK();
-  useEffect(() => {
-    if (!fileSha1 || !file)
-      return;
-    sdk.files.fetchFileFromUrl(file, fileSha1).then((file2) => {
-      setSrc(URL.createObjectURL(file2));
-    }).catch((reason) => {
-      console.error(`Failed to fetch file ${file} (${fileSha1}):
-`, reason);
-    });
-  }, [file, fileSha1, sdk.files]);
-  return src;
-};
-function downloadFile(file) {
-  const blob = new Blob([file]);
-  saveAs(blob, file.name);
-}
 const global$1 = typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
 function defaultSetTimout() {
   throw new Error("setTimeout has not been defined");
@@ -863,6 +515,106 @@ function classNames$1(...args) {
   }
   return classes.join(" ");
 }
+function hex(buffer) {
+  const hashArray = new Uint8Array(buffer);
+  return hashArray.reduce((data, byte) => data + byte.toString(16).padStart(2, "0"), "");
+}
+const getFileS3Key = async (file, hash) => {
+  if (!hash) {
+    hash = await hashFile(file);
+  }
+  let fileType = file.type;
+  if (fileType.includes("/")) {
+    fileType = fileType.split("/")[1];
+  }
+  if (!fileType) {
+    throw new Error(`Could not extract file type from ${file.type}`);
+  }
+  return `${hash}.${fileType}`;
+};
+function hashFile(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const fileResult = reader.result;
+      if (!fileResult) {
+        reject();
+        return;
+      }
+      void crypto.subtle.digest("SHA-1", fileResult).then((hash) => {
+        const sha1result = hex(hash);
+        resolve(sha1result);
+      });
+    };
+    reader.readAsArrayBuffer(file);
+  });
+}
+function getFileIdentifier(file) {
+  if (!file.name || !file.type || !file.size) {
+    const message = "File has no name, type, and/or size";
+    console.error(`${message}`, file);
+    throw new Error(`${message}.`);
+  }
+  return `${file.name}&${file.type}${file.size}`;
+}
+function getRenamedFile(file, newName) {
+  return new File([file], newName, { type: file.type });
+}
+function downloadInMemoryFile(filename, text) {
+  const element = document.createElement("a");
+  element.setAttribute("href", "data:text/plain;charset=utf-8," + encodeURIComponent(text));
+  element.setAttribute("download", filename);
+  element.style.display = "none";
+  document.body.appendChild(element);
+  element.click();
+  document.body.removeChild(element);
+}
+const constructUploadedFilePayloads = async (files) => {
+  const filePayloads = {};
+  for (const file of files) {
+    const sha1 = await hashFile(file);
+    filePayloads[sha1] = {
+      sha1,
+      extension: file.name.split(".").pop() || "",
+      file_type: file.type,
+      size: file.size
+    };
+  }
+  return Object.values(filePayloads);
+};
+const fileToBlob = async (dataUrl) => {
+  return (await fetch(dataUrl)).blob();
+};
+const blobToBase64 = (blob) => {
+  return new Promise((resolve, _) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      var _a2;
+      resolve(((_a2 = reader.result) == null ? void 0 : _a2.toString()) || "");
+    };
+    reader.readAsDataURL(blob);
+  });
+};
+const useFileSrc = (props) => {
+  const { file, fileSha1, placeholder } = props;
+  const [src, setSrc] = useState(placeholder);
+  const { sdk } = useSDK();
+  useEffect(() => {
+    if (!fileSha1 || !file)
+      return;
+    sdk.files.fetchFileFromUrl(file, fileSha1).then((file2) => {
+      setSrc(URL.createObjectURL(file2));
+    }).catch((reason) => {
+      console.error(`Failed to fetch file ${file} (${fileSha1}):
+`, reason);
+    });
+  }, [file, fileSha1, sdk.files]);
+  return src;
+};
+function downloadFile(file) {
+  const blob = new Blob([file]);
+  saveAs(blob, file.name);
+}
 const logCache = {};
 function logOnlyOnce(logId, objId, level, ...args) {
   const thisLogIdCache = logCache[logId];
@@ -5008,6 +4760,258 @@ function retry(_action, _retries) {
 }
 const useAppDispatch = () => useDispatch();
 const useAppSelector = useSelector;
+class OutboxCoordinator {
+  constructor() {
+    __publicField(this, "graph");
+    __publicField(this, "requestAttemptCounter");
+    this.graph = new DepGraph();
+    this.requestAttemptCounter = {};
+  }
+  /**
+   * Used when the app is loaded. Reconstructs the dependency graph based on an outbox from the redux-offline store.
+   */
+  static fromOutbox(outbox, client) {
+    const ret = new OutboxCoordinator();
+    for (let i = 0; i < outbox.length; i++) {
+      const outboxItem = outbox[i];
+      if (!outboxItem) {
+        console.error("Outbox item was undefined");
+        continue;
+      }
+      ret.sneakRequest(outboxItem);
+      for (let j = 0; j < i; j++) {
+        const previousOutboxItem = outbox[j];
+        if (!previousOutboxItem) {
+          console.error("Previous outbox item was undefined");
+          continue;
+        }
+        if (previousOutboxItem.payload.uuid === outboxItem.payload.uuid) {
+          continue;
+        }
+        if (previousOutboxItem.payload.blocks.some((block) => outboxItem.payload.blockers.includes(block))) {
+          OutboxCoordinator._addDependency(
+            outboxItem.payload.uuid,
+            previousOutboxItem.payload.uuid,
+            ret.graph
+          );
+        }
+      }
+    }
+    const firstRequest = ret.peek();
+    if (firstRequest) {
+      void performRequest(ret.pop(), client);
+    }
+    return ret;
+  }
+  _addDependency(from, to) {
+    OutboxCoordinator._addDependency(from, to, this.graph);
+  }
+  static _addDependency(from, to, graph) {
+    if (from === to) {
+      throw new Error(`Tried to add dependency from node to itself: ${from}`);
+    }
+    const fromExists = graph.hasNode(from);
+    if (!fromExists) {
+      throw new Error(`Tried to add dependency from non-existent node: ${from} (to node: ${to})`);
+    }
+    const toExists = graph.hasNode(to);
+    if (!toExists) {
+      throw new Error(`Tried to add dependency to non-existent node: ${to} (from node: ${from})`);
+    }
+    graph.addDependency(from, to);
+  }
+  /**
+   * If there are one or more nodes in the graph, we find all nodes that match a dependency of the request and add a
+   * dependency from the new request node to that node.
+   */
+  addRequest(request2) {
+    this.graph.addNode(request2.payload.uuid, request2);
+    if (request2.payload.blockers.length === 0 || this.graph.size() === 1) {
+      return;
+    }
+    for (const node of this.graph.overallOrder()) {
+      if (node === request2.payload.uuid)
+        continue;
+      const details = this.graph.getNodeData(node);
+      if (request2.payload.blockers.some((blocker) => details.payload.blocks.includes(blocker))) {
+        this._addDependency(request2.payload.uuid, node);
+      }
+    }
+  }
+  /**
+   * Inserts a request at the beginning of the queue. This could be used for requests that were popped, then failed,
+   * and need to be re-enqueued at the front of the queue. Any requests that were previously blocked by this request
+   * will be blocked by this request again. No blockers will be added to this request because it is assumed that the
+   * request was already unblocked when it was popped.
+   * @param request The request to insert at the beginning of the queue.
+   */
+  insertRequest(request2) {
+    this.graph.addNode(request2.payload.uuid, request2);
+    for (const node of this.graph.overallOrder()) {
+      if (node === request2.payload.uuid)
+        continue;
+      const details = this.graph.getNodeData(node);
+      if (details.payload.blockers.some((blocker) => request2.payload.blocks.includes(blocker))) {
+        this._addDependency(node, request2.payload.uuid);
+      }
+    }
+  }
+  /**
+   * Sneaks a request into the dependency graph without creating any blockers. Useful for reconstructing the graph
+   * (from the offline store's outbox state) when the app is loaded.
+   */
+  sneakRequest(request2) {
+    this.graph.addNode(request2.payload.uuid, request2);
+  }
+  /**
+   * Returns the next node in line to be sent. This is the unblocked node with the fewest number of attempts. If there
+   * are multiple nodes with the same number of attempts, the first one (by insertion order) will be returned.
+   */
+  _getNextNode() {
+    const leafNodes = this.graph.overallOrder(true);
+    let minAttempts = Infinity;
+    let minAttemptsNode;
+    for (const node of leafNodes) {
+      const attempts = this.requestAttemptCounter[node] || 0;
+      if (attempts < minAttempts) {
+        minAttempts = attempts;
+        minAttemptsNode = node;
+      }
+    }
+    return minAttemptsNode;
+  }
+  /**
+   * Returns the next request in line to be sent without removing it.
+   */
+  peek() {
+    const nextNode = this._getNextNode();
+    if (!nextNode)
+      return void 0;
+    return this.graph.getNodeData(nextNode);
+  }
+  /**
+   * Removes a request from the graph. This should be called when a request is successfully sent.
+   * @param uuid The UUID of the request to remove.
+   */
+  remove(uuid) {
+    this.graph.removeNode(uuid);
+    delete this.requestAttemptCounter[uuid];
+  }
+  /**
+   * Returns the next request in line to be sent and removes it from the graph.
+   */
+  pop() {
+    const nextRequestDetails = this.peek();
+    if (nextRequestDetails) {
+      this.graph.removeNode(nextRequestDetails.payload.uuid);
+    }
+    return nextRequestDetails;
+  }
+  /**
+   * Gets the current queue for the outbox. Should be called to get a new value for the outbox slice every time a
+   * request is enqueued. It will be used to render the outbox items in a single lane.
+   */
+  getQueue() {
+    const ret = this.graph.overallOrder().map((nodeName) => this.graph.getNodeData(nodeName));
+    const nextNode = this._getNextNode();
+    if (nextNode) {
+      const nextRequestDetails = this.graph.getNodeData(nextNode);
+      const nextRequestIndex = ret.findIndex(
+        (request2) => request2.payload.uuid === nextRequestDetails.payload.uuid
+      );
+      if (nextRequestIndex !== -1) {
+        ret.splice(nextRequestIndex, 1);
+        ret.unshift(nextRequestDetails);
+      }
+    }
+    return ret;
+  }
+  /**
+   * Gets a list of requests that can currently be sent (requests with no unresolved dependencies). Used to process
+   * the next ready request in case the request at the front of the queue is failing.
+   */
+  getReady() {
+    let ret = this.graph.overallOrder(true).map((nodeName) => this.graph.getNodeData(nodeName));
+    ret = ret.sort((a, b) => {
+      return a.meta.offline.effect.timestamp.localeCompare(b.meta.offline.effect.timestamp);
+    });
+    ret = ret.sort((a, b) => {
+      const aAttempts = this.requestAttemptCounter[a.payload.uuid] || 0;
+      const bAttempts = this.requestAttemptCounter[b.payload.uuid] || 0;
+      return aAttempts - bAttempts;
+    });
+    return ret;
+  }
+  registerRetry(uuid) {
+    this.requestAttemptCounter[uuid] = (this.requestAttemptCounter[uuid] || 0) + 1;
+  }
+}
+const UNKNOWN_ERROR_MESSAGE = "An unknown error occurred";
+const MAX_ERROR_MESSAGE_LENGTH = 500;
+const _SPECIAL_KEYS = ["non_field_errors", "detail"];
+function extractErrorMessage(errorRes, err) {
+  let ret;
+  if (errorRes == null ? void 0 : errorRes.body) {
+    if (typeof errorRes.body === "object") {
+      const responseBody = errorRes.body;
+      if (typeof responseBody.error === "string") {
+        ret = responseBody.error;
+      } else if (typeof responseBody.message === "string") {
+        ret = responseBody.message;
+      } else if (responseBody.body) {
+        try {
+          ret = Object.entries(responseBody.body).map(([key, value]) => {
+            if (typeof value === "string") {
+              if (_SPECIAL_KEYS.includes(key))
+                return value;
+              return `${key}: ${value}`;
+            }
+            if (Array.isArray(value)) {
+              if (_SPECIAL_KEYS.includes(key))
+                return value.join("\n");
+              return value.map((v) => `${key}: ${v}`).join("\n");
+            }
+            return `${key}: ${JSON.stringify(value)}`;
+          }).join("\n");
+        } catch (e) {
+          console.error("Failed to extract error message from response body", e);
+        }
+      }
+    } else if (typeof errorRes.body === "string") {
+      ret = errorRes.body;
+    }
+  } else if (errorRes == null ? void 0 : errorRes.text) {
+    ret = errorRes.text;
+  } else if (err instanceof Error) {
+    ret = err.message;
+  }
+  if (!ret || ret.length > MAX_ERROR_MESSAGE_LENGTH) {
+    return UNKNOWN_ERROR_MESSAGE;
+  }
+  return ret;
+}
+class APIError extends Error {
+  constructor(options) {
+    super(UNKNOWN_ERROR_MESSAGE);
+    // NOTE: Needs to conform to NetworkError in @redux-offline/redux-offline, which has `status` and `response`.
+    __publicField(this, "status");
+    __publicField(this, "response");
+    __publicField(this, "message");
+    __publicField(this, "options");
+    const { response, innerError } = options;
+    this.message = options.message ?? extractErrorMessage(response, innerError) ?? UNKNOWN_ERROR_MESSAGE;
+    this.status = (response == null ? void 0 : response.status) ?? 0;
+    this.response = response;
+    options.discard = options.discard ?? false;
+    this.options = options;
+  }
+}
+class BaseApiService {
+  constructor(sdk) {
+    __publicField(this, "client");
+    this.client = sdk;
+  }
+}
 const EXPIRING_SOON_THRESHOLD = 1800;
 function parseTokens(response) {
   if (!response.access)