@overmap-ai/core 1.0.65-mapbox.1 → 1.0.65-strip-workspace-access.1

package/dist/constants/offline.d.ts

@@ -1 +1 @@
-export declare const OUTBOX_RETRY_DELAY = 5000;
+export declare const OUTBOX_RETRY_DELAY = 60000;

package/dist/overmap-core.js

@@ -11,7 +11,7 @@ import { offline as offline$1 } from "@redux-offline/redux-offline";
 import offlineConfig from "@redux-offline/redux-offline/lib/defaults";
 import localforage from "localforage";
 import createMigration from "redux-persist-migrate";
-import { createSlice, createSelector, combineReducers, createNextState } from "@reduxjs/toolkit";
+import { createSlice, createSelector, combineReducers } from "@reduxjs/toolkit";
 import request from "superagent";
 import { saveAs } from "file-saver";
 import React, { useRef, useEffect } from "react";
@@ -409,21 +409,70 @@ const { setTokens, clearTokens, setLoggedIn } = authSlice.actions;
 const selectAccessToken = (state) => state.authReducer.accessToken;
 const selectIsLoggedIn = (state) => state.authReducer.isLoggedIn;
 const authReducer = authSlice.reducer;
-const createPointGeometry = (position) => {
+const coordinatesToLiteral = (coordinates) => {
+  return { lng: coordinates[0], lat: coordinates[1] };
+};
+const literalToCoordinates = (literal) => {
+  return [literal.lng, literal.lat];
+};
+const flipCoordinates = (coordinates) => {
+  return [coordinates[1], coordinates[0]];
+};
+const flipBounds = (bounds) => {
+  return [flipCoordinates(bounds[0]), flipCoordinates(bounds[1])];
+};
+function offsetPositionByMeters(originalPosition, latMeters, lngMeters) {
+  const { lat, lng } = originalPosition;
+  const earthRadius = 6378137;
+  const metersPerDegree = 2 * Math.PI * earthRadius / 360;
+  const newLng = lng + lngMeters / metersPerDegree / Math.cos(lat * Math.PI / 180);
+  const newLat = lat - latMeters / metersPerDegree;
+  return { lat: newLat, lng: newLng };
+}
+const createPointGeometry = (coordinates) => {
   return {
     type: "Point",
-    coordinates: position
+    coordinates
   };
 };
+const coordinatesAreEqual = (a, b) => {
+  return a[0] === b[0] && a[1] === b[1];
+};
+const coordinatesToText = (coordinates, decimalPlaces) => {
+  if (!coordinates)
+    return "(No Location)";
+  const { lat, lng } = coordinatesToLiteral(coordinates);
+  if (decimalPlaces)
+    return `${lat.toFixed(decimalPlaces)}, ${lng.toFixed(decimalPlaces)}`;
+  return `${lat}, ${lng}`;
+};
+const coordinatesToUrlText = (coordinates) => {
+  const { lat, lng } = coordinatesToLiteral(coordinates);
+  return `${lat}%2C${lng}`;
+};
+const openCoordsInGoogleMaps = (coordinates) => {
+  const url = `https://www.google.com/maps/search/?api=1&query=${coordinatesToUrlText(coordinates)}`;
+  window.open(url);
+};
+const openDirectionsInGoogleMaps = (startingPoint, destination) => {
+  const startingPointUrl = coordinatesToUrlText(startingPoint);
+  const destinationUrl = coordinatesToUrlText(destination);
+  const url = `https://www.google.com/maps/dir/?api=1&origin=${startingPointUrl}&destination=${destinationUrl}`;
+  window.open(url);
+};
+const worldBounds = {
+  type: "MultiPoint",
+  coordinates: [
+    [90, -180],
+    [-90, 180]
+  ]
+};
 const createMultiPointGeometry = (coordinates) => {
   return {
     type: "MultiPoint",
     coordinates
   };
 };
-const coordinatesAreEqual = (a, b) => {
-  return a[0] === b[0] && a[1] === b[1];
-};
 function classNames(...args) {
   const classes = [];
   for (const arg of args) {
@@ -601,11 +650,14 @@ function onlyUniqueHashes(value, index, self) {
     return v.file_sha1 === value.file_sha1;
   }) === index;
 }
+function boundsContainPoint(bounds, coordinates) {
+  return bounds[0][0] > coordinates[0] && bounds[1][0] < coordinates[0] && bounds[0][1] > coordinates[1] && bounds[1][1] < coordinates[1];
+}
 const emailRegex = /^.+@.+\..+$/;
 const fullAssetMarkerSize = 45;
 const DEFAULT_ISSUE_STATUS = IssueStatus.BACKLOG;
 const DEFAULT_ISSUE_PRIORITY = IssuePriority.MEDIUM;
-const OUTBOX_RETRY_DELAY = 5e3;
+const OUTBOX_RETRY_DELAY = 6e4;
 const EMPTY_ARRAY = Object.freeze([]);
 let debug = false;
 const REACT_APP_DEBUG_MEMOIZATION = {}.REACT_APP_DEBUG_MEMOIZATION || "";
@@ -2323,29 +2375,18 @@ const selectFilteredForms = restructureCreateSelectorWithArgs(
       (_state, search) => search
     ],
     (formsMapping, revisions, search) => {
-      const { searchTerm, maxResults, favorites, organization } = search;
-      const favoriteMatches = [];
+      const { searchTerm, maxResults, organization } = search;
       const regularMatches = [];
       for (const [formId, form] of Object.entries(formsMapping)) {
-        if (favorites !== void 0 && form.favorite != favorites)
-          continue;
         if (Number.isInteger(organization) && organization !== form.organization) {
           continue;
         }
         const latestRevision = _selectLatestFormRevision(revisions, formId);
         if (latestRevision.title.toLowerCase().includes(searchTerm.toLowerCase())) {
-          if (form.favorite) {
-            favoriteMatches.push({ ...form, latestRevision });
-          } else {
-            regularMatches.push({ ...form, latestRevision });
-          }
-        }
-        if (favoriteMatches.length >= maxResults) {
-          break;
+          regularMatches.push({ ...form, latestRevision });
         }
       }
-      const maxRegularMatches = maxResults - favoriteMatches.length;
-      return [...favoriteMatches, ...regularMatches.slice(0, maxRegularMatches)];
+      return [...regularMatches.slice(0, maxResults)];
     },
     // as the argument is an object, we check the first level of properties for equality
     { memoizeOptions: { equalityCheck: shallowEqual } }
@@ -3372,62 +3413,11 @@ const overmapReducers = {
 };
 const overmapReducer = combineReducers(overmapReducers);
 const resetStore = "RESET";
-function handleWorkspaceRemoval(draft, action) {
-  const workspaceId = action.payload;
-  const issuesVisibleInWorkspace = Object.values(draft.issueReducer.instances).filter(
-    (issue) => issue.visible_in_workspaces.includes(workspaceId)
-  );
-  const mainWorkspace = selectMainWorkspace(draft);
-  if (!mainWorkspace) {
-    throw new Error("Main workspace not found");
-  }
-  if (action.payload === mainWorkspace.offline_id) {
-    throw new Error("Tried to delete main workspace");
-  }
-  const categoriesInThisWorkspace = new Set(
-    selectCategoriesOfWorkspace(workspaceId)(draft).map((category) => category.offline_id)
-  );
-  for (const issue of issuesVisibleInWorkspace) {
-    if (issue.category && categoriesInThisWorkspace.has(issue.category)) {
-      issue.category = null;
-    }
-  }
-  const issuesWithThisWorkspaceIndex = issuesVisibleInWorkspace.filter(
-    (issue) => issue.index_workspace === action.payload
-  );
-  for (const issue of issuesWithThisWorkspaceIndex) {
-    issue.index_workspace = mainWorkspace.offline_id;
-    if (!issue.visible_in_workspaces.includes(mainWorkspace.offline_id)) {
-      issue.visible_in_workspaces.push(mainWorkspace.offline_id);
-    }
-  }
-  for (const issue of issuesVisibleInWorkspace) {
-    const indexOfWorkspace = issue.visible_in_workspaces.indexOf(workspaceId);
-    if (indexOfWorkspace === -1) {
-      throw new Error("Workspace not found in issue's visible_in_workspaces");
-    }
-    issue.visible_in_workspaces.splice(indexOfWorkspace, 1);
-  }
-  for (const issue of issuesVisibleInWorkspace) {
-    if (issue.visible_in_workspaces.length === 0) {
-      throw new Error(`Unexpected error: Issue ${issue.offline_id} has no visible_in_workspaces`);
-    }
-    if (issue.index_workspace === action.payload || !issue.index_workspace) {
-      throw new Error(`Failed to update index_workspace of issue ${issue.offline_id} to main workspace`);
-    }
-  }
-}
 const overmapRootReducer = (state, action) => {
   if (action.type === "auth/setLoggedIn" && !action.payload) {
     return overmapReducer(void 0, action);
   }
-  let mutatedState = state;
-  if (state && action.type === "workspace/removeWorkspace") {
-    mutatedState = createNextState(state, (draft) => {
-      handleWorkspaceRemoval(draft, action);
-    });
-  }
-  return overmapReducer(mutatedState, action);
+  return overmapReducer(state, action);
 };
 let __OUTBOX_COORDINATOR = null;
 function getOutboxCoordinator() {
@@ -4046,10 +4036,17 @@ class BaseApiService extends BaseService {
   }
 }
 class CategoryService extends BaseApiService {
-  add(category, workspaceId) {
-    const offlineCategory = offline(category);
-    const categoryWithWorkspace = { ...offlineCategory, workspace: workspaceId };
-    this.dispatch(addCategory(categoryWithWorkspace));
+  add(payload, workspaceId) {
+    const { store } = this.client;
+    const createdBy = store.getState().userReducer.currentUser.id;
+    const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const offlineCategory = offline({
+      ...payload,
+      created_by: createdBy,
+      submitted_at: submittedAt,
+      workspace: workspaceId
+    });
+    this.dispatch(addCategory(offlineCategory));
     const promise = this.enqueueRequest({
       description: "Create Category",
       method: HttpMethod.POST,
@@ -4058,10 +4055,10 @@ class CategoryService extends BaseApiService {
         workspace_id: workspaceId.toString()
       },
       payload: offlineCategory,
-      blockers: [],
+      blockers: [workspaceId],
       blocks: [offlineCategory.offline_id]
     });
-    return [categoryWithWorkspace, promise];
+    return [offlineCategory, promise];
   }
   update(category, workspaceId) {
     const state = this.client.store.getState();
@@ -4931,11 +4928,7 @@ class IssueService extends BaseApiService {
         ...issueType ? { issue_type: issueType } : {}
       },
       payload: issuePayload,
-      blockers: [
-        "add-issue",
-        ...issuePayload.index_workspace ? [issuePayload.index_workspace] : [],
-        ...issuePayload.visible_in_workspaces
-      ],
+      blockers: ["add-issue", ...issuePayload.index_workspace ? [issuePayload.index_workspace] : []],
       blocks: [issuePayload.offline_id]
     });
     void promise.then((result) => {
@@ -5716,48 +5709,6 @@ class FormService extends BaseUploadService {
     });
     return [fullRevision, offlineFormRevisionAttachments, promise, attachmentsPromise];
   }
-  async favorite(formId, projectId) {
-    const { store } = this.client;
-    const state = store.getState();
-    const form = state.formReducer.instances[formId];
-    if (!form) {
-      throw new Error(`Expected form to exist, got ${form}`);
-    }
-    this.dispatch(updateForm({ ...form, favorite: true }));
-    try {
-      await this.enqueueRequest({
-        description: "Favorite form",
-        method: HttpMethod.POST,
-        url: `/forms/${formId}/favorite/${projectId}/`,
-        blockers: [formId, `favorite-${formId}`],
-        blocks: [`favorite-${formId}`]
-      });
-    } catch (e) {
-      this.dispatch(updateForm(form));
-      throw e;
-    }
-  }
-  async unfavorite(formId, projectId) {
-    const { store } = this.client;
-    const state = store.getState();
-    const form = state.formReducer.instances[formId];
-    if (!form) {
-      throw new Error(`Expected form to exist, got ${form}`);
-    }
-    this.dispatch(updateForm({ ...form, favorite: false }));
-    try {
-      return await this.enqueueRequest({
-        description: "Unfavorite form",
-        method: HttpMethod.DELETE,
-        url: `/forms/${formId}/unfavorite/${projectId}/`,
-        blockers: [formId, `favorite-${formId}`],
-        blocks: [`favorite-${formId}`]
-      });
-    } catch (e) {
-      this.dispatch(updateForm(form));
-      throw e;
-    }
-  }
   async delete(formId) {
     const { store } = this.client;
     const state = store.getState();
@@ -6218,13 +6169,19 @@ class FormSubmissionService extends BaseUploadService {
   }
 }
 class WorkspaceService extends BaseApiService {
-  add(workspace) {
-    const offlineWorkspace = offline(workspace);
+  add(payload) {
+    const { store } = this.client;
+    const createdBy = store.getState().userReducer.currentUser.id;
+    const offlineWorkspace = offline({
+      ...payload,
+      submitted_at: (/* @__PURE__ */ new Date()).toISOString(),
+      created_by: createdBy
+    });
     this.dispatch(addWorkspace(offlineWorkspace));
     const promise = this.enqueueRequest({
       description: "Create Workspace",
       method: HttpMethod.POST,
-      url: `/projects/${workspace.project}/workspaces/`,
+      url: `/projects/${payload.project}/workspaces/`,
       payload: offlineWorkspace,
       blockers: ["add-workspace"],
       blocks: [offlineWorkspace.offline_id]
@@ -7637,6 +7594,7 @@ export {
   authReducer,
   authSlice,
   blobToBase64,
+  boundsContainPoint,
   categoryReducer,
   categorySlice,
   classNames,
@@ -7644,6 +7602,9 @@ export {
   clearTokens,
   constructUploadedFilePayloads,
   coordinatesAreEqual,
+  coordinatesToLiteral,
+  coordinatesToText,
+  coordinatesToUrlText,
   createMultiPointGeometry,
   createOfflineAction,
   createPointGeometry,
@@ -7706,6 +7667,8 @@ export {
   fileReducer,
   fileSlice,
   fileToBlob,
+  flipBounds,
+  flipCoordinates,
   formReducer,
   formRevisionAttachmentReducer,
   formRevisionAttachmentSlice,
@@ -7772,14 +7735,18 @@ export {
   issueUpdateSlice,
   licenseReducer,
   licenseSlice,
+  literalToCoordinates,
   logOnlyOnce,
   markAsDeleted,
   markForDeletion,
   memoize,
   moveDocument,
   offline,
+  offsetPositionByMeters,
   onlyUniqueHashes,
   onlyUniqueOfflineIds,
+  openCoordsInGoogleMaps,
+  openDirectionsInGoogleMaps,
   organizationAccessReducer,
   organizationAccessSlice,
   organizationReducer,
@@ -8094,6 +8061,7 @@ export {
   versioningSlice,
   warningColor,
   workspaceReducer,
-  workspaceSlice
+  workspaceSlice,
+  worldBounds
 };
 //# sourceMappingURL=overmap-core.js.map