@svar-ui/gantt-data-provider 2.7.2 → 2.8.0

package/dist/index.js

@@ -201,7 +201,7 @@ var ActionQueue = class {
             copy = { ...obj };
           }
           copy[key] = hasRealID;
-        } else if (!ignore) {
+        } else if (test !== ignore) {
           return cantSendYet;
         }
       }
@@ -316,7 +316,7 @@ var Rest = class extends EventBus {
     if (data) {
       req.body = typeof data === "object" ? this.toPayload(data) : data;
     }
-    const slash = this._url.charAt(-1) === "/" || url[0] === "/" ? "" : "/";
+    const slash = !url || this._url.endsWith("/") || url[0] === "/" ? "" : "/";
     return fetch(`${this._url}${slash}${url || ""}`, req).then(
       (res) => res.json()
     );
@@ -3056,26 +3056,34 @@ function cleanEscapedString(input) {
   return matched[1].replace(doubleQuoteRegExp, "'");
 }
 
+const TaskID = 1;
+const LinkID = 2;
+const AssignmentID = 3;
+
+const DATE_KEYS = ["start", "end", "base_start", "base_end", "deadline"];
 class RestDataProvider extends Rest {
   changeQueue = [];
   _batchUrl;
   flushTimeout = null;
+  headers = {};
   constructor(url, config) {
     super(url);
     this._batchUrl = config?.batchURL;
   }
+  setHeaders(headers) {
+    this.headers = headers;
+  }
   getHandlers() {
     return {
       "add-task": {
         ignoreID: true,
-        handler: async (ev) => {
-          ev.task.parent = this.correctID(ev.task.parent);
-          return this.sendBatch(`tasks`, "POST", {
-            task: ev.task,
-            mode: ev.mode,
-            target: this.correctID(ev.target)
-          });
-        }
+        kind: TaskID,
+        handler: async (ev) => this.sendBatch(`tasks`, "POST", {
+          task: ev.task,
+          target: ev.target,
+          mode: ev.mode,
+          index: ev.index
+        })
       },
       "update-task": {
         debounce: 500,
@@ -3090,15 +3098,15 @@ class RestDataProvider extends Rest {
       },
       "copy-task": {
         ignoreID: true,
-        handler: async (ev) => {
-          return this.sendBatch(`tasks/${ev.source}`, "PUT", {
-            operation: "copy",
-            id: ev.id,
-            target: this.correctID(ev.target),
-            mode: ev.mode,
-            lazy: !!ev.lazy
-          });
-        }
+        kind: TaskID,
+        handler: async (ev) => this.sendBatch(`tasks/${ev.source}`, "PUT", {
+          operation: "copy",
+          id: ev.id,
+          target: ev.target,
+          mode: ev.mode,
+          index: ev.index,
+          lazy: !!ev.lazy
+        })
       },
       "move-task": {
         handler: async (ev) => {
@@ -3113,11 +3121,8 @@ class RestDataProvider extends Rest {
       },
       "add-link": {
         ignoreID: true,
-        handler: async (ev) => {
-          ev.link.source = this.correctID(ev.link.source);
-          ev.link.target = this.correctID(ev.link.target);
-          return this.sendBatch(`links`, "POST", ev.link);
-        }
+        kind: LinkID,
+        handler: async (ev) => this.sendBatch(`links`, "POST", ev.link)
       },
       "update-link": {
         handler: async (ev) => this.sendBatch(`links/${ev.id}`, "PUT", ev.link)
@@ -3127,26 +3132,22 @@ class RestDataProvider extends Rest {
       },
       "add-assignment": {
         ignoreID: true,
-        handler: async (ev) => {
-          ev.assignment.task = this.correctID(ev.assignment.task);
-          return this.sendBatch(`assignments`, "POST", ev.assignment);
-        }
+        kind: AssignmentID,
+        handler: async (ev) => this.sendBatch(
+          `assignments`,
+          "POST",
+          ev.assignment
+        )
       },
       "delete-assignment": {
-        handler: async (ev) => {
-          this.sendBatch(`assignments/${ev.id}`, "DELETE");
-        }
+        handler: async (ev) => this.sendBatch(`assignments/${ev.id}`, "DELETE")
       },
       "update-assignment": {
-        handler: async (ev) => {
-          const { task } = ev.assignment;
-          if (task) ev.assignment.task = this.correctID(task);
-          this.sendBatch(
-            `assignments/${ev.id}`,
-            "PUT",
-            ev.assignment
-          );
-        }
+        handler: async (ev) => this.sendBatch(
+          `assignments/${ev.id}`,
+          "PUT",
+          ev.assignment
+        )
       }
     };
   }
@@ -3163,7 +3164,7 @@ class RestDataProvider extends Rest {
       ) : void 0
     ]);
     const tasks = this.parseDates(tasksResponse).map((t) => {
-      if (t.parent == id) t.parent = tempId;
+      if (t.parent === id) t.parent = tempId;
       return t;
     });
     const result = { tasks, links };
@@ -3173,10 +3174,16 @@ class RestDataProvider extends Rest {
   }
   parseDates(data) {
     data.forEach((item) => {
-      item.start = new Date(item.start);
-      if (item.end) item.end = new Date(item.end);
-      if (item.base_start) item.base_start = new Date(item.base_start);
-      if (item.base_end) item.base_end = new Date(item.base_end);
+      DATE_KEYS.forEach((key) => {
+        if (item[key]) item[key] = new Date(item[key]);
+      });
+      if (item.constraint?.date)
+        item.constraint.date = new Date(item.constraint.date);
+      item.segments?.forEach((segment) => {
+        DATE_KEYS.forEach((key) => {
+          if (segment[key]) segment[key] = new Date(segment[key]);
+        });
+      });
     });
     return data;
   }
@@ -3190,46 +3197,72 @@ class RestDataProvider extends Rest {
       return this.send(url, method, data, customHeaders);
     }
   }
+  resolveId(id, kind) {
+    return this.getQueue().resolve(id, kind);
+  }
   async sendBatchRequest(url, method, data, customHeaders) {
-    this.changeQueue.push({ url, method, data });
-    if (this.flushTimeout) {
-      clearTimeout(this.flushTimeout);
-    }
-    return new Promise((resolve) => {
-      this.flushTimeout = setTimeout(async () => {
-        if (this.changeQueue.length > 1) {
-          const batchData = this.changeQueue.map((req) => {
-            return {
-              url: req.url,
-              method: req.method,
-              data: {
-                ...req.data
-              }
-            };
-          });
-          this.changeQueue = [];
-          const result = await this.send(
-            this._batchUrl,
-            "POST",
-            batchData
-          );
-          resolve(result);
-        } else {
-          this.changeQueue = [];
-          const result = await this.send(
-            url,
-            method,
-            data,
-            customHeaders
-          );
-          resolve(result);
-        }
-      }, 10);
+    const request = new Promise((resolve, reject) => {
+      this.changeQueue.push({
+        url,
+        method,
+        data,
+        customHeaders,
+        resolve,
+        reject
+      });
     });
+    if (this.flushTimeout) clearTimeout(this.flushTimeout);
+    this.flushTimeout = setTimeout(() => this.flushBatch(), 10);
+    return request;
+  }
+  async flushBatch() {
+    const queue = this.changeQueue;
+    this.changeQueue = [];
+    this.flushTimeout = null;
+    if (!queue.length) return;
+    if (queue.length === 1) {
+      const [req] = queue;
+      try {
+        req.resolve(
+          await this.send(
+            req.url,
+            req.method,
+            req.data,
+            req.customHeaders
+          )
+        );
+      } catch (error) {
+        req.reject(error);
+      }
+      return;
+    }
+    const batchData = queue.map((req) => ({
+      url: req.url,
+      method: req.method,
+      data: req.data ? { ...req.data } : void 0,
+      customHeaders: req.customHeaders
+    }));
+    try {
+      const result = await this.send(
+        this._batchUrl,
+        "POST",
+        batchData
+      );
+      if (!Array.isArray(result))
+        throw new Error("batch endpoint did not return a list");
+      queue.forEach((req, i) => {
+        const response = result[i];
+        if (response?.error) req.reject(new Error(response.error));
+        else req.resolve(response);
+      });
+    } catch (error) {
+      queue.forEach((req) => req.reject(error));
+    }
   }
   async send(url, method, data, customHeaders = {}) {
     const headers = {
       "Content-Type": "application/json",
+      ...this.headers,
       ...customHeaders
     };
     const req = {
@@ -3239,39 +3272,408 @@ class RestDataProvider extends Rest {
     if (data) {
       req.body = this.getPayload(data);
     }
-    return fetch(`${this._url}/${url}`, req).then((res) => {
-      return res.json().catch((error) => {
-        console.error(error);
-      });
+    return fetch(`${this._url}/${url}`, req).then(async (res) => {
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(
+          `request failed with status ${res.status}${text ? `: ${text}` : ""}`
+        );
+      }
+      return res.json();
     });
   }
   getPayload(obj) {
-    const transformedObj = this.transformDates(obj);
-    return JSON.stringify(transformedObj);
+    return JSON.stringify(this.transformDates(obj));
   }
   transformDates = (item) => {
-    if (Array.isArray(item)) {
-      return item.map(this.transformDates);
-    }
+    if (item instanceof Date) return this.formatDate(item);
+    if (Array.isArray(item)) return item.map(this.transformDates);
     if (typeof item === "object" && item !== null) {
-      for (const key in item) {
-        const value = item[key];
-        if (value instanceof Date) {
-          item[key] = this.formatDate(value);
-        } else if (typeof value === "object") {
-          item[key] = this.transformDates(value);
-        }
-      }
+      const copy = {};
+      for (const key in item) copy[key] = this.transformDates(item[key]);
+      return copy;
     }
     return item;
   };
-  correctID(localId) {
-    const tempId = localId;
-    const id = this.getQueue().getId(tempId);
-    if (localId !== id) return id;
-    return localId;
+}
+
+const RETRY_MIN = 1e3;
+const RETRY_MAX = 3e4;
+class EventStream {
+  config;
+  eventSource = null;
+  connectedSignal = null;
+  // Resolves when eventSource opens
+  wasOpen = false;
+  hasMissedEvents = false;
+  isOnline = false;
+  rejectConnect = null;
+  retryTimer = null;
+  retryDelayMs = RETRY_MIN;
+  isStopped = false;
+  constructor(config) {
+    this.config = config;
+  }
+  connect() {
+    this.isStopped = false;
+    if (this.connectedSignal) return this.connectedSignal;
+    this.connectedSignal = new Promise((resolve, reject) => {
+      this.rejectConnect = reject;
+      this.eventSource = new EventSource(this.getURL(), {
+        withCredentials: this.config.withCredentials
+      });
+      const source = this.eventSource;
+      source.onopen = () => {
+        if (this.eventSource !== source) return;
+        const resync = this.wasOpen || this.hasMissedEvents;
+        this.wasOpen = true;
+        this.hasMissedEvents = false;
+        this.retryDelayMs = RETRY_MIN;
+        this.rejectConnect = null;
+        resolve();
+        this.notify(true);
+        if (resync) this.config.onResync?.();
+      };
+      source.onerror = () => {
+        if (this.eventSource !== source) return;
+        this.notify(false);
+        if (source.readyState !== EventSource.CLOSED) return;
+        this.close();
+        this.hasMissedEvents = true;
+        this.rejectConnect?.(
+          new Error("could not open the event stream")
+        );
+        this.rejectConnect = null;
+        this.scheduleRetry();
+      };
+      source.onmessage = (message) => {
+        if (this.eventSource !== source) return;
+        this.config.onMessage?.(message.data);
+      };
+    });
+    return this.connectedSignal;
+  }
+  disconnect() {
+    this.isStopped = true;
+    this.clearRetry();
+    this.close();
+    this.rejectConnect?.(
+      new Error("disconnected before the stream was open")
+    );
+    this.rejectConnect = null;
+    this.notify(false);
+  }
+  scheduleRetry() {
+    if (this.isStopped || this.retryTimer) return;
+    const delayMs = this.retryDelayMs * (0.5 + Math.random() / 2);
+    this.retryDelayMs = Math.min(this.retryDelayMs * 2, RETRY_MAX);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      if (this.isStopped) return;
+      this.connect().catch(() => {
+      });
+    }, delayMs);
+  }
+  clearRetry() {
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+    this.retryDelayMs = RETRY_MIN;
+  }
+  close() {
+    this.eventSource?.close();
+    this.eventSource = null;
+    this.connectedSignal = null;
+  }
+  notify(isOnline) {
+    if (this.isOnline === isOnline) return;
+    this.isOnline = isOnline;
+    try {
+      this.config.onConnectionChange?.(isOnline);
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  getURL() {
+    const { url, params } = this.config;
+    const query = new URLSearchParams(
+      typeof params === "function" ? params() : params
+    ).toString();
+    if (!query) return url;
+    return url + (url.includes("?") ? "&" : "?") + query;
+  }
+}
+
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  } else {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+      const num = Math.random() * 16 | 0;
+      const value = char === "x" ? num : num & 3 | 8;
+      return value.toString(16);
+    });
+  }
+}
+
+const PARAMS = {
+  eventSource: "remote"
+};
+class RemoteEvents {
+  // the host sends it as X-Client-Id, so the server skips this client's own echo
+  clientId = generateUUID();
+  provider;
+  api;
+  eventStream;
+  constructor(provider, config) {
+    this.provider = provider;
+    const { params } = config;
+    this.eventStream = new EventStream({
+      ...config,
+      onMessage: config.onMessage ?? ((msg) => this.processMessage(msg)),
+      params: () => ({
+        ...typeof params === "function" ? params() : params,
+        clientId: this.clientId
+      })
+    });
+  }
+  connect(api) {
+    this.api = api;
+    return this.eventStream.connect();
+  }
+  disconnect() {
+    this.eventStream.disconnect();
+  }
+  processMessage(message) {
+    const event = this.parseMessage(message);
+    if (!event || !this.api) return;
+    try {
+      this.applyEvent(event);
+    } catch (error) {
+      console.error("failed to apply a remote event", error);
+    }
+  }
+  applyEvent(event) {
+    switch (event.type) {
+      case "task":
+        return this.applyEventTask(event);
+      case "link":
+        return this.applyEventLink(event);
+      case "assignment":
+        return this.applyEventAssignment(event);
+    }
+  }
+  // ---------- Task events ----------
+  applyEventTask(event) {
+    const id = this.resolveRemoteId(event.id, TaskID);
+    let task;
+    if (event.data) {
+      const data = [event.data];
+      task = (this.provider.parseDates?.(data) ?? data)[0];
+    }
+    const operation = task?.operation;
+    if (task) {
+      task.id = id;
+      task.parent = this.resolveRemoteId(task.parent, TaskID);
+      if ("target" in task)
+        task.target = this.resolveRemoteId(task.target, TaskID);
+      delete task.open;
+      delete task.operation;
+    }
+    switch (event.action) {
+      case "add":
+        if (this.isTaskLoaded(id)) return;
+        return this.applyEventTaskAdd(id, task);
+      case "update":
+        return this.applyEventTaskUpdate(id, task, operation);
+      case "delete":
+        return this.applyEventTaskDelete(id);
+    }
+  }
+  applyEventTaskAdd(id, task) {
+    if (!task) return;
+    if (!this.canAcceptChild(task?.parent)) return;
+    const hasTarget = this.isTaskLoaded(task?.target);
+    const addTask = { ...task };
+    delete addTask.index;
+    delete addTask.target;
+    delete addTask.mode;
+    this.api.exec("add-task", {
+      id,
+      task: addTask,
+      target: hasTarget ? task?.target : void 0,
+      mode: hasTarget ? task?.mode : void 0,
+      index: task?.index,
+      ...PARAMS
+    });
+  }
+  applyEventTaskUpdate(id, task, operation) {
+    if (!task) return;
+    if (!this.isTaskLoaded(id)) {
+      return this.applyEventTaskAdd(id, task);
+    }
+    delete task.lazy;
+    if (!operation) {
+      this.api.exec("update-task", {
+        id,
+        task,
+        ...PARAMS
+      });
+    } else if (operation === "move") {
+      if (!this.canAcceptChild(task?.parent)) {
+        return this.applyEventTaskDelete(id);
+      }
+      const hasTarget = this.isTaskLoaded(task?.target);
+      this.api.exec("move-task", {
+        id,
+        target: hasTarget ? task?.target : task?.parent,
+        mode: hasTarget ? task?.mode : "child",
+        ...PARAMS
+      });
+    }
+  }
+  applyEventTaskDelete(id) {
+    if (!this.isTaskLoaded(id)) return;
+    this.api.exec("delete-task", {
+      id,
+      ...PARAMS
+    });
+  }
+  // ---------- Link events ----------
+  applyEventLink(event) {
+    const id = this.resolveRemoteId(event.id, LinkID);
+    const link = event.data ? event.data : void 0;
+    if (link) {
+      link.id = id;
+      link.source = this.resolveRemoteId(link.source, TaskID);
+      link.target = this.resolveRemoteId(link.target, TaskID);
+    }
+    switch (event.action) {
+      case "add":
+        return this.applyEventLinkAdd(id, link);
+      case "update":
+        return this.applyEventLinkUpdate(id, link);
+      case "delete":
+        return this.applyEventLinkDelete(id);
+    }
+  }
+  applyEventLinkAdd(id, link) {
+    if (!link) return;
+    if (this.isLinkLoaded(id)) return;
+    if (!this.isTaskLoaded(link.source) || !this.isTaskLoaded(link.target))
+      return;
+    this.api.exec("add-link", {
+      id,
+      link,
+      ...PARAMS
+    });
+  }
+  applyEventLinkUpdate(id, link) {
+    if (!link) return;
+    if (!this.isLinkLoaded(id)) return;
+    this.api.exec("update-link", {
+      id,
+      link,
+      ...PARAMS
+    });
+  }
+  applyEventLinkDelete(id) {
+    if (!this.isLinkLoaded(id)) return;
+    this.api.exec("delete-link", {
+      id,
+      ...PARAMS
+    });
+  }
+  // ---------- Assignment events ----------
+  applyEventAssignment(event) {
+    const id = this.resolveRemoteId(event.id, AssignmentID);
+    const assignment = event.data ? event.data : void 0;
+    if (assignment) {
+      assignment.id = id;
+      assignment.task = this.resolveRemoteId(assignment.task, TaskID);
+    }
+    switch (event.action) {
+      case "add":
+        return this.applyEventAssignmentAdd(id, assignment);
+      case "update":
+        return this.applyEventAssignmentUpdate(id, assignment);
+      case "delete":
+        return this.applyEventAssignmentDelete(id);
+    }
+  }
+  applyEventAssignmentAdd(id, assignment) {
+    if (!assignment) return;
+    if (this.isAssignmentLoaded(id)) return;
+    if (!this.isTaskLoaded(assignment.task)) return;
+    this.api.exec("add-assignment", {
+      id,
+      assignment,
+      ...PARAMS
+    });
+  }
+  applyEventAssignmentUpdate(id, assignment) {
+    if (!assignment) return;
+    if (!this.isAssignmentLoaded(id)) return;
+    this.api.exec("update-assignment", {
+      id,
+      assignment,
+      ...PARAMS
+    });
+  }
+  applyEventAssignmentDelete(id) {
+    if (!this.isAssignmentLoaded(id)) return;
+    this.api.exec("delete-assignment", {
+      id,
+      ...PARAMS
+    });
+  }
+  // ---------- Helpers ----------
+  resolveRemoteId(id, kind) {
+    if (id === null || typeof id === "undefined") return id;
+    const localId = this.provider.resolveId(id, kind) ?? id;
+    if (localId === id) return id;
+    return this.doesItemExist(localId, kind) ? localId : id;
+  }
+  doesItemExist(id, kind) {
+    switch (kind) {
+      case TaskID:
+        return !!this.api.getTask(id);
+      case LinkID:
+        return this.isLinkLoaded(id);
+      case AssignmentID:
+        return this.isAssignmentLoaded(id);
+      default:
+        return true;
+    }
+  }
+  isTaskLoaded(id) {
+    return !id || !!this.api.getTask(id);
+  }
+  canAcceptChild(id) {
+    if (!id) return true;
+    const parent = this.api.getTask(id);
+    return !!parent && !parent.lazy;
+  }
+  isLinkLoaded(id) {
+    return !!this.api.getState().links.byId(id);
+  }
+  isAssignmentLoaded(id) {
+    return !!this.api.getState().assignments?.byId(id);
+  }
+  // ---------- Parsing ----------
+  parseMessage(message) {
+    const clientId = this.clientId;
+    let data;
+    try {
+      data = JSON.parse(message);
+    } catch {
+      return null;
+    }
+    if (data === null || typeof data !== "object" || !("from" in data) || data.from === clientId || !("type" in data) || typeof data.type !== "string" || !("action" in data) || typeof data.action !== "string" || !("id" in data)) {
+      return null;
+    }
+    return data;
   }
 }
 
-export { RestDataProvider };
+export { AssignmentID, EventStream, LinkID, RemoteEvents, RestDataProvider, TaskID };
 //# sourceMappingURL=index.js.map