@monkvision/network 4.0.0

package/LICENSE

@@ -0,0 +1,32 @@
+The Clear BSD License
+
+Copyright (c) [2022] [Monk](http://monk.ai)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted (subject to the limitations in the disclaimer
+below) provided that the following conditions are met:
+
+     * Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+
+     * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+     * Neither the name of the copyright holder nor the names of its
+     contributors may be used to endorse or promote products derived from this
+     software without specific prior written permission.
+
+NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,225 @@
+# @monkvision/network
+This package provides tools used by the MonkJs SDK to interact with the Network (authentication, API calls...).
+
+# Installing
+To install the package, you can run the following command :
+
+```shell
+yarn add @monkvision/network
+```
+
+If you are using TypeScript, this package comes with its type definitions integrated, so you don't need to install
+anything else!
+
+# API Requests
+This package exports an object called `MonkApi` that regroups the different API requests available. The request
+available in this pacakge all follow the same format :
+
+- They can accept a certain amount of parameters
+- The last parameters of the function will always be :
+  - The `apiConfig` object, that describes how to communicate with the
+    API (API domain and authentication token).
+  - An optional MonkState `dispatch` function that, if provided to the request function, will allow it to automatically
+    update the local React state. If not provided, the function will act as a simple TypeScript function with no React
+    functionality. To help you integrate Monk API requests more easily into your React apps, take a look at the
+    `useMonkApi` hook below.
+- Their return type always contains at least the following properties:
+  - `body` : The API response body.
+  - `response` :  The raw HTTP response object.
+
+### getInspection
+```typescript
+import { MonkApi } from '@monkvision/network';
+
+MonkApi.getInspection(options, apiConfig, dispatch);
+```
+
+Fetch the details of an inspection using its ID. The resulting action of this request will contain the list of
+every entity that has been fetched using this API call.
+
+| Parameter | Type                 | Description                 | Required |
+|-----------|----------------------|-----------------------------|----------|
+| options   | GetInspectionOptions | The options of the request. | ✔️       |
+
+### addImage
+```typescript
+import { MonkApi } from '@monkvision/network';
+
+MonkApi.addImage(options, apiConfig, dispatch);
+```
+
+Add a new image to an inspection. The resulting action of this request will contain the details of the image that has
+been created in the API.
+
+| Parameter | Type            | Description                                              | Required |
+|-----------|-----------------|----------------------------------------------------------|----------|
+| options   | AddImageOptions | The options used to specify how to upload the image.     | ✔️       |
+
+### updateTaskStatus
+```typescript
+import { MonkApi } from '@monkvision/network';
+import { ProgressStatus, TaskName } from '@monkvision/types';
+
+MonkApi.updateTaskStatus(options, apiConfig, dispatch);
+```
+
+Update the progress status of an inspection task.
+
+**Note : This API call is known to sometimes fail for unknown reasons. In order to fix this, we added a retry config
+to this API request : when failing, this request will retry itself up to 4 times (5 API calls in total), with
+exponentially increasing delay between each request (max delay : 1.5s).**
+
+| Parameter | Type                    | Description                                              | Required |
+|-----------|-------------------------|----------------------------------------------------------|----------|
+| options   | UpdateTaskStatusOptions | The options of the request.                              | ✔️       |
+
+### startInspectionTasks
+```typescript
+import { MonkApi } from '@monkvision/network';
+import { TaskName } from '@monkvision/types';
+
+MonkApi.startInspectionTasks(options, apiConfig, dispatch);
+```
+
+Start some inspection tasks that were in the NOT_STARTED status. This function actually makes one API call for each
+task provided using the `updateTaskStatus`.
+
+**Note : This API call is known to sometimes fail for unknown reasons. Please take note of the details provided in
+this documentation for the `updateTaskStatus` function.**
+
+| Parameter | Type                        | Description                                              | Required |
+|-----------|-----------------------------|----------------------------------------------------------|----------|
+| options   | StartInspectionTasksOptions | The options of the request.                              | ✔️       |
+
+### getLiveConfig
+```typescript
+import { MonkApi } from '@monkvision/network';https://acvauctions.fls.jetbrains.com
+
+MonkApi.getLiveConfig(id);
+```
+
+Fetch a webapp live configuration from the API.
+
+| Parameter | Type   | Description                       | Required |
+|-----------|--------|-----------------------------------|----------|
+| id        | string | The ID of the live config to get. | ✔️       |
+
+### updateInspectionVehicle
+```typescript
+import { MonkApi } from '@monkvision/network';
+
+MonkApi.updateInspectionVehicule(options, apiConfig, dispatch);
+```
+
+Update the vehicle of an inspection.
+
+| Parameter | Type                           | Description                 | Required |
+|-----------|--------------------------------|-----------------------------|----------|
+| options   | UpdateInspectionVehicleOptions | The options of the request. | ✔️       |
+
+# React Tools
+In order to simply integrate the Monk Api requests into your React app, you can make use of the `useMonkApi` hook. This
+custom hook returns a custom version of the `MonkApi` object described in the section above, in which the requests do
+not need to be passed the `apiConfig` parameter (since it is already provided to the `useMonkApi` hook) and the
+MonkState `dispatch` function.
+
+```tsx
+import { useEffect } from 'react';
+import { MonkApi, useMonkApi } from '@monkvision/network';
+import { TaskName } from '@monkvision/types';
+
+function App() {
+  const { getInspection } = useMonkApi(apiConfig);
+
+  useEffect(() => {
+    // This call automatically syncs the local state with the distant state, which means that entities located in the
+    // MonkState (accessed using the `useMonkState` hook) are automatically updated after the response from the server.
+    getInspection(inspectionId);
+  }, []);
+}
+```
+
+## Hooks
+This package also exports useful Network hooks that you can use in your React apps.
+
+### useInspectionPoll
+```tsx
+import { useInspectionPoll } from '@monkvision/network';
+
+function TestComponent() {
+  useInspectionPoll({
+    id: myInspectionId,
+    delay: 2000,
+    apiConfig,
+    onSuccess: (entities) => console.log(entities.inspections.find((inspection) => inspection.id === myInspectionId)),
+    compliance,
+  });
+}
+```
+Custom hook used to fetch an inspection every `delay` milliseconds using the `getInspection` API request. To stop the
+hook from making requests, simply pass a `null` vlaue for the `delay` param.
+
+# Authentication
+This package also exports tools for dealing with authentication within the Monk SDK :
+
+## useAuth hook
+This package exports a custom hook called `useAuth` used to easily handle authentication in Monk applications. It stores
+the current user's authentication token, and returns callbacks used to log in and out of the application using Auth0
+pop-ups. It accepts a config option called `storeToken` that indicates if the token should be fetched and stored from
+the browser local storage (default : `true`).
+
+- For this hook to work properly, you must use it in a component that is a child of an `Auth0Provider` component.
+- This hook automatically stores the token fetched in the `useMonkAppState` hook so that it can be accessed
+  anywhere in your app if you're using the `MonkAppStateProvider`.
+
+```tsx
+function MyAuthComponent() {
+  const { login } = useAuth();
+  const navigate = useNavigate();
+
+  const handleLogIn = () => {
+    login().then(() => {
+      navigate('/home');
+    });
+  };
+
+  return <button onClick={handleLogIn}>Log In</button>;
+}
+```
+
+## JWT Utils
+### Token decoding
+You can decode Monk JWT token issued by Auth0 using the `decodeMonkJwt` util function provided by this package :
+
+```typescript
+import { decodeMonkJwt, MonkJwtPayload } from '@monkvision/network';
+
+const decodedToken: MonkJwtPayload =  decodeMonkJwt(token);
+```
+
+The available properties in the Monk JWT token payload are described in the `MonkJwtPayload` typescript interface.
+
+### isUserAuthorized
+This utility function checks if the given user has all the required authroizations. You can either pass an auth token
+to be decoded or the JWT payload directly.
+
+```typescript
+import { MonkApiPermission } from '@monkvision/types';
+import { isUserAuthorized } from '@monkvision/network';
+
+const requiredPermissions = [MonkApiPermission.INSPECTION_CREATE, MonkApiPermission.INSPECTION_READ];
+console.log(isUserAuthorized(value, requiredPermissions));
+// value can either be an auth token as a string or a decoded JWT payload
+```
+
+
+### isTokenExpired
+This utility function checks if an authorization token is expired or not. You can either pass an auth token to be
+decoded or the JWT payload directly.
+
+```typescript
+import { isTokenExpired } from '@monkvision/network';
+
+console.log(isTokenExpired(value));
+// value can either be an auth token as a string or a decoded JWT payload
+```

package/lib/package.json

@@ -0,0 +1,84 @@
+{
+    "name": "@monkvision/network",
+    "version": "4.0.0",
+    "license": "BSD-3-Clause-Clear",
+    "packageManager": "yarn@3.2.4",
+    "description": "MonkJs core package used to communicate with the API",
+    "author": "monkvision",
+    "main": "lib/src/index.js",
+    "types": "lib/src/index.d.ts",
+    "files": [
+        "package.json",
+        "README.md",
+        "lib"
+    ],
+    "scripts": {
+        "clean": "rimraf lib && mkdirp lib",
+        "build": "yarn run clean && tsc -p tsconfig.build.json",
+        "test": "jest",
+        "test:coverage": "jest --coverage",
+        "prettier": "prettier --check ./src ./test",
+        "prettier:fix": "prettier --write ./src ./test",
+        "eslint": "eslint --format=pretty ./src ./test",
+        "eslint:fix": "eslint --fix --format=pretty ./src ./test",
+        "lint": "yarn run prettier && yarn run eslint",
+        "lint:fix": "yarn run prettier:fix && yarn run eslint:fix"
+    },
+    "dependencies": {
+        "@monkvision/common": "4.0.0",
+        "@monkvision/sights": "4.0.0",
+        "jsonwebtoken": "^9.0.2",
+        "jwt-decode": "^4.0.0",
+        "ky": "^1.2.0",
+        "uuid": "^9.0.1"
+    },
+    "peerDependencies": {
+        "@auth0/auth0-react": "^2.2.4",
+        "react": "^17.0.2",
+        "react-dom": "^17.0.2",
+        "react-router-dom": "^6.22.3"
+    },
+    "devDependencies": {
+        "@monkvision/eslint-config-base": "4.0.0",
+        "@monkvision/eslint-config-typescript": "4.0.0",
+        "@monkvision/jest-config": "4.0.0",
+        "@monkvision/prettier-config": "4.0.0",
+        "@monkvision/types": "4.0.0",
+        "@monkvision/typescript-config": "4.0.0",
+        "@types/jest": "^29.2.2",
+        "@types/jsonwebtoken": "^9.0.5",
+        "@types/node": "^18.11.9",
+        "@types/uuid": "^9",
+        "@typescript-eslint/eslint-plugin": "^5.43.0",
+        "@typescript-eslint/parser": "^5.43.0",
+        "eslint": "^8.29.0",
+        "eslint-config-airbnb-base": "^15.0.0",
+        "eslint-config-prettier": "^8.5.0",
+        "eslint-formatter-pretty": "^4.1.0",
+        "eslint-plugin-eslint-comments": "^3.2.0",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-jest": "^25.3.0",
+        "eslint-plugin-prettier": "^4.2.1",
+        "eslint-plugin-promise": "^6.1.1",
+        "eslint-utils": "^3.0.0",
+        "jest": "^29.3.1",
+        "mkdirp": "^1.0.4",
+        "prettier": "^2.7.1",
+        "regexpp": "^3.2.0",
+        "rimraf": "^3.0.2",
+        "ts-jest": "^29.0.3",
+        "typescript": "^4.8.4"
+    },
+    "prettier": "@monkvision/prettier-config",
+    "publishConfig": {
+        "access": "public"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/monkvision/monkjs.git"
+    },
+    "bugs": {
+        "url": "https://github.com/monkvision/monkjs/issues"
+    },
+    "homepage": "https://github.com/monkvision/monkjs"
+}

package/lib/src/api/api.d.ts

@@ -0,0 +1,18 @@
+import { getInspection, createInspection } from './inspection';
+import { addImage } from './image';
+import { startInspectionTasks, updateTaskStatus } from './task';
+import { getLiveConfig } from './liveConfigs';
+import { updateInspectionVehicle } from './vehicle';
+/**
+ * Object regrouping the different API requests available to communicate with the API using the `@monkvision/network`
+ * package.
+ */
+export declare const MonkApi: {
+    getInspection: typeof getInspection;
+    createInspection: typeof createInspection;
+    addImage: typeof addImage;
+    updateTaskStatus: typeof updateTaskStatus;
+    startInspectionTasks: typeof startInspectionTasks;
+    getLiveConfig: typeof getLiveConfig;
+    updateInspectionVehicle: typeof updateInspectionVehicle;
+};

package/lib/src/api/api.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonkApi = void 0;
+var inspection_1 = require("./inspection");
+var image_1 = require("./image");
+var task_1 = require("./task");
+var liveConfigs_1 = require("./liveConfigs");
+var vehicle_1 = require("./vehicle");
+/**
+ * Object regrouping the different API requests available to communicate with the API using the `@monkvision/network`
+ * package.
+ */
+exports.MonkApi = {
+    getInspection: inspection_1.getInspection,
+    createInspection: inspection_1.createInspection,
+    addImage: image_1.addImage,
+    updateTaskStatus: task_1.updateTaskStatus,
+    startInspectionTasks: task_1.startInspectionTasks,
+    getLiveConfig: liveConfigs_1.getLiveConfig,
+    updateInspectionVehicle: vehicle_1.updateInspectionVehicle,
+};
+//# sourceMappingURL=api.js.map

package/lib/src/api/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../src/api/api.ts"],"names":[],"mappings":";;;AAAA,2CAA+D;AAC/D,iCAAmC;AACnC,+BAAgE;AAChE,6CAA8C;AAC9C,qCAAoD;AAEpD;;;GAGG;AACU,QAAA,OAAO,GAAG;IACrB,aAAa,4BAAA;IACb,gBAAgB,+BAAA;IAChB,QAAQ,kBAAA;IACR,gBAAgB,yBAAA;IAChB,oBAAoB,6BAAA;IACpB,aAAa,6BAAA;IACb,uBAAuB,mCAAA;CACxB,CAAC"}

package/lib/src/api/config.d.ts

@@ -0,0 +1,20 @@
+import { Options } from 'ky';
+export declare const sdkVersion: string;
+/**
+ * Required configuration properties used when interacting with the MonkJs API.
+ */
+export interface MonkApiConfig {
+    /**
+     * The domain of the Monk API.
+     */
+    apiDomain: string;
+    /**
+     * The authentication token used to communicate with the API.
+     */
+    authToken: string;
+    /**
+     * The API domain used to communicate with the resize micro service.
+     */
+    thumbnailDomain: string;
+}
+export declare function getDefaultOptions(config?: MonkApiConfig): Options;

package/lib/src/api/config.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultOptions = exports.sdkVersion = void 0;
+var package_json_1 = __importDefault(require("../../package.json"));
+var error_1 = require("./error");
+exports.sdkVersion = package_json_1.default.version;
+function getPrefixUrl(config) {
+    if (!config) {
+        return undefined;
+    }
+    var apiDomain = config.apiDomain.endsWith('/')
+        ? config.apiDomain.substring(0, config.apiDomain.length - 1)
+        : config.apiDomain;
+    return "https://".concat(apiDomain);
+}
+function getAuthorizationHeader(config) {
+    if (!config) {
+        return undefined;
+    }
+    return config.authToken.startsWith('Bearer ') ? config.authToken : "Bearer ".concat(config.authToken);
+}
+function getDefaultOptions(config) {
+    return {
+        prefixUrl: getPrefixUrl(config),
+        headers: {
+            'Accept': 'application/json, text/plain, */*',
+            'Access-Control-Allow-Origin': '*',
+            'Authorization': getAuthorizationHeader(config),
+            'X-Monk-SDK-Version': exports.sdkVersion,
+        },
+        hooks: {
+            beforeError: [error_1.beforeError],
+        },
+        timeout: 30000,
+    };
+}
+exports.getDefaultOptions = getDefaultOptions;
+//# sourceMappingURL=config.js.map

package/lib/src/api/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/api/config.ts"],"names":[],"mappings":";;;;;;AACA,oEAA6C;AAC7C,iCAAsC;AAEzB,QAAA,UAAU,GAAG,sBAAW,CAAC,OAAO,CAAC;AAoB9C,SAAS,YAAY,CAAC,MAAsB;IAC1C,IAAI,CAAC,MAAM,EAAE;QACX,OAAO,SAAS,CAAC;KAClB;IACD,IAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC;QAC9C,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5D,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC;IACrB,OAAO,kBAAW,SAAS,CAAE,CAAC;AAChC,CAAC;AAED,SAAS,sBAAsB,CAAC,MAAsB;IACpD,IAAI,CAAC,MAAM,EAAE;QACX,OAAO,SAAS,CAAC;KAClB;IACD,OAAO,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,iBAAU,MAAM,CAAC,SAAS,CAAE,CAAC;AAClG,CAAC;AAED,SAAgB,iBAAiB,CAAC,MAAsB;IACtD,OAAO;QACL,SAAS,EAAE,YAAY,CAAC,MAAM,CAAC;QAC/B,OAAO,EAAE;YACP,QAAQ,EAAE,mCAAmC;YAC7C,6BAA6B,EAAE,GAAG;YAClC,eAAe,EAAE,sBAAsB,CAAC,MAAM,CAAC;YAC/C,oBAAoB,EAAE,kBAAU;SACjC;QACD,KAAK,EAAE;YACL,WAAW,EAAE,CAAC,mBAAW,CAAC;SAC3B;QACD,OAAO,EAAE,KAAK;KACf,CAAC;AACJ,CAAC;AAdD,8CAcC"}

package/lib/src/api/error.d.ts

@@ -0,0 +1,34 @@
+import { HTTPError } from 'ky';
+import { BeforeErrorHook } from 'ky/distribution/types/hooks';
+import { ApiError } from './models';
+/**
+ * Enumeration of names of known error that can occur when making Monk api requests.
+ */
+export declare enum MonkNetworkError {
+    /**
+     * The authentication token was not provided.
+     */
+    MISSING_TOKEN = "MissingToken",
+    /**
+     * The authentication token provided in the request is invalid (badly formatted etc.).
+     */
+    INVALID_TOKEN = "InvalidToken",
+    /**
+     * The authentication token provided in the request is expired.
+     */
+    EXPIRED_TOKEN = "TokenExpired",
+    /**
+     * The user corresponding to the authentication token provided in the request does not have the sufficient
+     * authorization to perform the request.
+     */
+    INSUFFICIENT_AUTHORIZATION = "InsufficientAuthorization"
+}
+/**
+ * Type definition for a network error catched by the Monk SDK. Requests made by this package will usually process the
+ * error returned by the API and will include the request body (containing the error message) with the Error object
+ * itself.
+ */
+export interface MonkHTTPError extends HTTPError {
+    body?: ApiError;
+}
+export declare const beforeError: BeforeErrorHook;

package/lib/src/api/error.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeError = exports.MonkNetworkError = void 0;
+/**
+ * Enumeration of names of known error that can occur when making Monk api requests.
+ */
+var MonkNetworkError;
+(function (MonkNetworkError) {
+    /**
+     * The authentication token was not provided.
+     */
+    MonkNetworkError["MISSING_TOKEN"] = "MissingToken";
+    /**
+     * The authentication token provided in the request is invalid (badly formatted etc.).
+     */
+    MonkNetworkError["INVALID_TOKEN"] = "InvalidToken";
+    /**
+     * The authentication token provided in the request is expired.
+     */
+    MonkNetworkError["EXPIRED_TOKEN"] = "TokenExpired";
+    /**
+     * The user corresponding to the authentication token provided in the request does not have the sufficient
+     * authorization to perform the request.
+     */
+    MonkNetworkError["INSUFFICIENT_AUTHORIZATION"] = "InsufficientAuthorization";
+})(MonkNetworkError = exports.MonkNetworkError || (exports.MonkNetworkError = {}));
+function getErrorMessage(name) {
+    switch (name) {
+        case MonkNetworkError.MISSING_TOKEN:
+            return 'Missing authentication token in request headers.';
+        case MonkNetworkError.INVALID_TOKEN:
+            return 'Invalid authentication token in request.';
+        case MonkNetworkError.EXPIRED_TOKEN:
+            return 'Authentication token is expired.';
+        case MonkNetworkError.INSUFFICIENT_AUTHORIZATION:
+            return 'User does not have the proper authorization grants to perform this request.';
+        default:
+            return null;
+    }
+}
+function getErrorName(status, message) {
+    if (status === 401 && message.includes('Authorization header is required')) {
+        return MonkNetworkError.MISSING_TOKEN;
+    }
+    if (status === 401 &&
+        [
+            'Token payload schema unknown',
+            'Token decode failed',
+            'Token audience invalid, please check audience',
+            'Token issuer invalid, please check issuer',
+            'Wrong authorization header format, should be in the format : Bearer TOKEN',
+            'Invalid authentication token in request.',
+        ].some(function (str) { return message.includes(str); })) {
+        return MonkNetworkError.INVALID_TOKEN;
+    }
+    if (status === 401 && message.includes('Token is expired')) {
+        return MonkNetworkError.EXPIRED_TOKEN;
+    }
+    // TODO : Also check conditions for MonkNetworkError.INSUFFICIENT_AUTHORIZATION.
+    return null;
+}
+/* eslint-disable no-param-reassign */
+var beforeError = function (error) { return __awaiter(void 0, void 0, void 0, function () {
+    var response, clone, body;
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                response = error.response;
+                clone = response.clone();
+                return [4 /*yield*/, clone.json()];
+            case 1:
+                body = (_c.sent());
+                error.name = (_a = getErrorName(clone.status, body.message)) !== null && _a !== void 0 ? _a : error.name;
+                error.message = (_b = getErrorMessage(error.name)) !== null && _b !== void 0 ? _b : error.message;
+                Object.assign(error, { body: body });
+                return [2 /*return*/, error];
+        }
+    });
+}); };
+exports.beforeError = beforeError;
+//# sourceMappingURL=error.js.map

package/lib/src/api/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../src/api/error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;GAEG;AACH,IAAY,gBAkBX;AAlBD,WAAY,gBAAgB;IAC1B;;OAEG;IACH,kDAA8B,CAAA;IAC9B;;OAEG;IACH,kDAA8B,CAAA;IAC9B;;OAEG;IACH,kDAA8B,CAAA;IAC9B;;;OAGG;IACH,4EAAwD,CAAA;AAC1D,CAAC,EAlBW,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAkB3B;AAED,SAAS,eAAe,CAAC,IAAY;IACnC,QAAQ,IAAI,EAAE;QACZ,KAAK,gBAAgB,CAAC,aAAa;YACjC,OAAO,kDAAkD,CAAC;QAC5D,KAAK,gBAAgB,CAAC,aAAa;YACjC,OAAO,0CAA0C,CAAC;QACpD,KAAK,gBAAgB,CAAC,aAAa;YACjC,OAAO,kCAAkC,CAAC;QAC5C,KAAK,gBAAgB,CAAC,0BAA0B;YAC9C,OAAO,6EAA6E,CAAC;QACvF;YACE,OAAO,IAAI,CAAC;KACf;AACH,CAAC;AAED,SAAS,YAAY,CAAC,MAAc,EAAE,OAAe;IACnD,IAAI,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,kCAAkC,CAAC,EAAE;QAC1E,OAAO,gBAAgB,CAAC,aAAa,CAAC;KACvC;IACD,IACE,MAAM,KAAK,GAAG;QACd;YACE,8BAA8B;YAC9B,qBAAqB;YACrB,+CAA+C;YAC/C,2CAA2C;YAC3C,2EAA2E;YAC3E,0CAA0C;SAC3C,CAAC,IAAI,CAAC,UAAC,GAAG,IAAK,OAAA,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAArB,CAAqB,CAAC,EACtC;QACA,OAAO,gBAAgB,CAAC,aAAa,CAAC;KACvC;IACD,IAAI,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE;QAC1D,OAAO,gBAAgB,CAAC,aAAa,CAAC;KACvC;IACD,gFAAgF;IAChF,OAAO,IAAI,CAAC;AACd,CAAC;AAWD,sCAAsC;AAC/B,IAAM,WAAW,GAAoB,UAAO,KAAgB;;;;;;gBACzD,QAAQ,GAAK,KAAK,SAAV,CAAW;gBACrB,KAAK,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC;gBACjB,qBAAM,KAAK,CAAC,IAAI,EAAE,EAAA;;gBAA1B,IAAI,GAAG,CAAC,SAAkB,CAAa;gBAC7C,KAAK,CAAC,IAAI,GAAG,MAAA,YAAY,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,mCAAI,KAAK,CAAC,IAAI,CAAC;gBACpE,KAAK,CAAC,OAAO,GAAG,MAAA,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,mCAAI,KAAK,CAAC,OAAO,CAAC;gBAC7D,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,IAAI,MAAA,EAAE,CAAC,CAAC;gBAC/B,sBAAO,KAAK,EAAC;;;KACd,CAAC;AARW,QAAA,WAAW,eAQtB"}

package/lib/src/api/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useInspectionPoll';

package/lib/src/api/hooks/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useInspectionPoll"), exports);
+//# sourceMappingURL=index.js.map

package/lib/src/api/hooks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/api/hooks/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,sDAAoC"}