@trap_stevo/filetide 0.0.66 → 0.0.67

package/dist/cjs/FileMessager.js

@@ -19,6 +19,10 @@ const {
 const {
   FileTransferManager
 } = require("./HUDManagers/FileTransferManager");
+const {
+  aggregateMultiAverageChartData,
+  aggregateChartData
+} = require("./HUDManagers/TidalyticsUtilityManager");
 const TideSentinelManager = require("./HUDManagers/TideSentinelManager");
 const HUDTargetQueue = require("./HUDManagers/HUDTargetQueueManager");
 const {
@@ -132,6 +136,899 @@ class FileMessager {
   clearAllTidalytics() {
     return tidalytics.clearAllMetrics();
   }
+  attachTiderPresenceVisualStream(options = {}) {
+    const {
+      visualDataConfigurations = {},
+      mode = "buffer",
+      forward
+    } = options;
+    if (!forward) {
+      return;
+    }
+    async function handle() {
+      if (mode === "signal") {
+        forward("rehydrate");
+        return;
+      }
+      const result = await getTiderPresenceVisualData(visualDataConfigurations);
+      forward(result);
+    }
+    tidalytics.events.on("metric:created:tider:offline", handle);
+    tidalytics.events.on("metric:created:tider:online", handle);
+  }
+  attachAlreadyOnlineVisualStream(options = {}) {
+    const {
+      visualDataConfigurations = {},
+      mode = "buffer",
+      forward
+    } = options;
+    if (!forward) {
+      return;
+    }
+    async function handle() {
+      if (mode === "signal") {
+        forward("rehydrate");
+        return;
+      }
+      const result = await getAlreadyOnlineVisualData(visualDataConfigurations);
+      forward(result);
+    }
+    tidalytics.events.on("metric:created:tider:already-online", handle);
+  }
+  attachTiderBanVisualStream(options = {}) {
+    const {
+      visualDataConfigurations = {},
+      mode = "buffer",
+      forward
+    } = options;
+    if (!forward) {
+      return;
+    }
+    async function handle() {
+      if (mode === "signal") {
+        forward("rehydrate");
+        return;
+      }
+      const result = await getTiderBanVisualData(visualDataConfigurations);
+      forward(result);
+    }
+    tidalytics.events.on("metric:created:tider:unbanned", handle);
+    tidalytics.events.on("metric:created:tider:banned", handle);
+    tidalytics.events.on("metric:created:tider:kicked", handle);
+  }
+  attachTideFileTransferVisualStream(options = {}) {
+    const {
+      visualDataConfigurations = {},
+      mode = "buffer",
+      forward
+    } = options;
+    if (!forward) {
+      return;
+    }
+    async function handle() {
+      if (mode === "signal") {
+        forward("rehydrate");
+        return;
+      }
+      const result = await getTideFileTransferVisualData(visualDataConfigurations);
+      forward(result);
+    }
+    tidalytics.events.on("metric:created:tide:completed-transfer", handle);
+    tidalytics.events.on("metric:created:tide:incoming-transfer", handle);
+    tidalytics.events.on("metric:created:tide:incoming-file", handle);
+  }
+  attachTideTransferStateVisualStream(options = {}) {
+    const {
+      visualDataConfigurations = {},
+      mode = "buffer",
+      forward
+    } = options;
+    if (!forward) {
+      return;
+    }
+    async function handle() {
+      if (mode === "signal") {
+        forward("rehydrate");
+        return;
+      }
+      const result = await getTideTransferStateVisualData(visualDataConfigurations);
+      forward(result);
+    }
+    tidalytics.events.on("metric:created:tide:transfer-state", handle);
+  }
+  attachFileListVisualStream(options = {}) {
+    const {
+      visualDataConfigurations = {},
+      mode = "buffer",
+      forward
+    } = options;
+    if (!forward) {
+      return;
+    }
+    async function handle() {
+      if (mode === "signal") {
+        forward("rehydrate");
+        return;
+      }
+      const result = await getFileListVisualData(visualDataConfigurations);
+      forward(result);
+    }
+    tidalytics.events.on("metric:created:file-list:received", handle);
+    tidalytics.events.on("metric:created:file-list:request", handle);
+  }
+  attachTideBarrierVisualStream(options = {}) {
+    const {
+      visualDataConfigurations = {},
+      mode = "buffer",
+      forward
+    } = options;
+    if (!forward) {
+      return;
+    }
+    async function handle() {
+      if (mode === "signal") {
+        forward("rehydrate");
+        return;
+      }
+      const result = await getTideBarrierVisualData(visualDataConfigurations);
+      forward(result);
+    }
+    tidalytics.events.on("metric:created:tide-barrier:accepted", handle);
+    tidalytics.events.on("metric:created:tide-barrier:denied", handle);
+  }
+  async getTiderPresenceVisualData(options = {}) {
+    const {
+      interval = "1d",
+      limit = Infinity,
+      filter = {},
+      mode = "all"
+    } = options;
+    const sources = ["storage", "memory"];
+    const [storedOnline, storedOffline] = await Promise.all([this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tider:online": "tider:online"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tider:offline": "tider:offline"
+      }
+    })]);
+    const [liveOnline] = await Promise.all([this.getTidalyticsSince(interval, sources[1], {
+      ...filter,
+      tags: {
+        "tider:online": "tider:online"
+      }
+    })]);
+    const onlineMetrics = [...storedOnline, ...liveOnline];
+    const offlineMetrics = storedOffline;
+    const sessionsByKey = {};
+    for (const event of onlineMetrics) {
+      const user = event.metadata?.user;
+      const connectionID = event.metadata?.connectionID;
+      const connectedOn = event.metadata?.connectedOn || event.timestamp;
+      const key = `${user}_${connectionID}`;
+      sessionsByKey[key] = {
+        sessionDuration: null,
+        disconnectedOn: null,
+        connectionID,
+        connectedOn,
+        user
+      };
+    }
+    for (const event of offlineMetrics) {
+      const user = event.metadata?.user;
+      const connectionID = event.metadata?.connectionID;
+      const disconnectedOn = event.timestamp;
+      const key = `${user}_${connectionID}`;
+      if (sessionsByKey[key]) {
+        sessionsByKey[key].sessionDuration = disconnectedOn - sessionsByKey[key].connectedOn;
+        sessionsByKey[key].disconnectedOn = disconnectedOn;
+      }
+    }
+    let allSessions = Object.values(sessionsByKey);
+    if (mode === "online") {
+      allSessions = allSessions.filter(session => session.disconnectedOn === null);
+    } else if (mode === "offline") {
+      allSessions = allSessions.filter(session => session.disconnectedOn !== null);
+    }
+    return limit === Infinity ? allSessions : allSessions.slice(-limit).reverse();
+  }
+  async getAlreadyOnlineVisualData(options = {}) {
+    const {
+      interval = "1d",
+      filter = {},
+      limit = Infinity,
+      format = "raw",
+      chartConfig = {}
+    } = options;
+    const fullChartConfig = {
+      groupBy: "metadata.user",
+      mode: "count",
+      valueKey: "value",
+      metadataFields: null,
+      previewLimit: 3,
+      ...chartConfig
+    };
+    const sources = ["storage", "memory"];
+    const [alreadyOnlineEvents, onlineJoins] = await Promise.all([this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tider:already-online": "tider:already-online"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tider:online": "tider:online"
+      }
+    })]);
+    const entries = alreadyOnlineEvents.map(e => ({
+      ...e,
+      type: "already-online"
+    })).sort((a, b) => b.timestamp - a.timestamp);
+    const joinCountsByUser = {};
+    for (const evt of onlineJoins) {
+      const user = evt.metadata?.user;
+      if (!user) {
+        continue;
+      }
+      joinCountsByUser[user] = (joinCountsByUser[user] || 0) + 1;
+    }
+    if (format === "chart") {
+      const result = fullChartConfig.mode === "average" ? aggregateMultiAverageChartData(entries, {
+        ...fullChartConfig,
+        groupBy: [].concat(fullChartConfig.groupBy)
+      }) : aggregateChartData(entries, {
+        ...fullChartConfig,
+        typeKey: "type"
+      });
+      return result.map(entry => {
+        const userKey = entry.label;
+        const totalJoins = joinCountsByUser[userKey] || 0;
+        return {
+          ...entry,
+          totalJoins,
+          collisionRate: totalJoins > 0 ? +(entry.count / totalJoins).toFixed(3) : 0
+        };
+      });
+    }
+    return limit === Infinity ? entries : entries.slice(0, limit);
+  }
+  async getTiderBanVisualData(options = {}) {
+    const {
+      interval = "1d",
+      filter = {},
+      limit = Infinity,
+      format = "raw",
+      chartConfig = {}
+    } = options;
+    const fullChartConfig = {
+      groupBy: "type",
+      mode: "count",
+      ...chartConfig
+    };
+    const sources = ["storage", "memory"];
+    const [banned, kicked, unbanned] = await Promise.all([this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tider:banned": "tider:banned"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tider:kicked": "tider:kicked"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tider:unbanned": "tider:unbanned"
+      }
+    })]);
+    const entries = [...banned.map(e => ({
+      ...e,
+      type: "banned"
+    })), ...kicked.map(e => ({
+      ...e,
+      type: "kicked"
+    })), ...unbanned.map(e => ({
+      ...e,
+      type: "unbanned"
+    }))].sort((a, b) => b.timestamp - a.timestamp);
+    if (format === "chart") {
+      return fullChartConfig.mode === "average" ? aggregateMultiAverageChartData(entries, {
+        ...fullChartConfig,
+        groupBy: [].concat(fullChartConfig.groupBy)
+      }) : aggregateChartData(entries, {
+        ...fullChartConfig,
+        typeKey: "type"
+      });
+    }
+    return limit === Infinity ? entries : entries.slice(0, limit);
+  }
+  async getTideFileTransferVisualData(options = {}) {
+    const {
+      interval = "1d",
+      filter = {},
+      limit = Infinity,
+      format = "raw",
+      chartConfig = {}
+    } = options;
+    const fullChartConfig = {
+      groupBy: "type",
+      mode: "count",
+      ...chartConfig
+    };
+    const sources = ["storage", "memory"];
+    const [incomingTransfers, incoming, completed] = await Promise.all([this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tide:incoming-transfer": "tide:incoming-transfer"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tide:incoming-file": "tide:incoming-file"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tide:completed-transfer": "tide:completed-transfer"
+      }
+    })]);
+    const entries = [...incomingTransfers.map(e => ({
+      ...e,
+      type: "incoming-transfer"
+    })), ...incoming.map(e => ({
+      ...e,
+      type: "incoming"
+    })), ...completed.map(e => ({
+      ...e,
+      type: "completed"
+    }))].sort((a, b) => b.timestamp - a.timestamp);
+    if (format === "chart") {
+      return fullChartConfig.mode === "average" ? aggregateMultiAverageChartData(entries, {
+        ...fullChartConfig,
+        groupBy: [].concat(fullChartConfig.groupBy)
+      }) : aggregateChartData(entries, {
+        ...fullChartConfig,
+        typeKey: "type"
+      });
+    }
+    return limit === Infinity ? entries : entries.slice(0, limit);
+  }
+  async getTideTransferStateVisualData(options = {}) {
+    const {
+      interval = "1d",
+      filter = {},
+      limit = Infinity,
+      format = "raw",
+      chartConfig = {}
+    } = options;
+    const fullChartConfig = {
+      groupBy: "metadata.transferStateID",
+      mode: "average",
+      valueKey: "metadata.speed",
+      metadataFields: ["senderID", "recipientID", "transferProgress", "speed", "transferETA", "fileName"],
+      previewLimit: 3,
+      ...chartConfig
+    };
+    const sources = ["storage", "memory"];
+    const [transferStates] = await Promise.all([this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tide:transfer-state": "tide:transfer-state"
+      }
+    })]);
+    const entries = transferStates.map(e => ({
+      ...e,
+      type: "transfer-state"
+    })).sort((a, b) => b.timestamp - a.timestamp);
+    if (format === "chart") {
+      return fullChartConfig.mode === "average" ? aggregateMultiAverageChartData(entries, {
+        ...fullChartConfig,
+        groupBy: [].concat(fullChartConfig.groupBy)
+      }) : aggregateChartData(entries, {
+        ...fullChartConfig,
+        typeKey: "type"
+      });
+    }
+    return limit === Infinity ? entries : entries.slice(0, limit);
+  }
+  async getFileListActivityVisualData(options = {}) {
+    const {
+      interval = "1d",
+      filter = {},
+      limit = Infinity,
+      format = "raw",
+      chartConfig = {}
+    } = options;
+    const fullChartConfig = {
+      groupBy: "type",
+      mode: "count",
+      ...chartConfig
+    };
+    const sources = ["storage", "memory"];
+    const [requested, received] = await Promise.all([this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "file-list:request": "file-list:request"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "file-list:received": "file-list:received"
+      }
+    })]);
+    const entries = [...requested.map(e => ({
+      ...e,
+      type: "requested"
+    })), ...received.map(e => ({
+      ...e,
+      type: "received"
+    }))].sort((a, b) => b.timestamp - a.timestamp);
+    if (format === "chart") {
+      return fullChartConfig.mode === "average" ? aggregateMultiAverageChartData(entries, {
+        ...fullChartConfig,
+        groupBy: [].concat(fullChartConfig.groupBy)
+      }) : aggregateChartData(entries, {
+        ...fullChartConfig,
+        typeKey: "type"
+      });
+    }
+    return limit === Infinity ? entries : entries.slice(0, limit);
+  }
+  async getTideBarrierVisualData(options = {}) {
+    const {
+      interval = "1d",
+      filter = {},
+      limit = Infinity,
+      format = "raw",
+      chartConfig = {}
+    } = options;
+    const fullChartConfig = {
+      groupBy: "type",
+      mode: "count",
+      ...chartConfig
+    };
+    const sources = ["storage", "memory"];
+    const [accepted, denied] = await Promise.all([this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tide-barrier:accepted": "tide-barrier:accepted"
+      }
+    }), this.getTidalyticsSince(interval, sources[0], {
+      ...filter,
+      tags: {
+        "tide-barrier:denied": "tide-barrier:denied"
+      }
+    })]);
+    const entries = [...accepted.map(e => ({
+      ...e,
+      type: "accepted"
+    })), ...denied.map(e => ({
+      ...e,
+      type: "denied"
+    }))].sort((a, b) => b.timestamp - a.timestamp);
+    if (format === "chart") {
+      return fullChartConfig.mode === "average" ? aggregateMultiAverageChartData(entries, {
+        ...fullChartConfig,
+        groupBy: [].concat(fullChartConfig.groupBy)
+      }) : aggregateChartData(entries, {
+        ...fullChartConfig,
+        typeKey: "type"
+      });
+    }
+    return limit === Infinity ? entries : entries.slice(0, limit);
+  }
+
+  // --- File Messager Tide Actions Management ---
+
+  async getTideCompletedTransferActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tide:completed-transfer": "tide:completed-transfer"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tide-completed-transfer",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        recipientID: event.metadata?.recipientID,
+        senderID: event.metadata?.senderID,
+        path: event.metadata?.path,
+        fileSize: event.metadata?.fileSize,
+        fileName: event.metadata?.fileName,
+        completedChunks: event.metadata?.completedChunks,
+        totalChunks: event.metadata?.totalChunks,
+        chunkSize: event.metadata?.chunkSize
+      }
+    }));
+  }
+  async getTideTransferStateActions({
+    interval = "1d",
+    limit = Infinity,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tide:transfer-state": "tide:transfer-state"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tide-transfer-state",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        transferStateID: event.metadata?.transferStateID,
+        recipientID: event.metadata?.recipientID,
+        senderID: event.metadata?.senderID,
+        path: event.metadata?.path,
+        startTime: event.metadata?.startTime,
+        currentTransferredSize: event.metadata?.currentTransferredSize,
+        speed: event.metadata?.speed,
+        transferProgress: event.metadata?.transferProgress,
+        transferSize: event.metadata?.transferSize,
+        transferETA: event.metadata?.transferETA,
+        fileName: event.metadata?.fileName
+      }
+    }));
+  }
+  async getTideIncomingFileActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tide:incoming-file": "tide:incoming-file"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tide-incoming-file",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        recipientID: event.metadata?.recipientID,
+        senderID: event.metadata?.senderID,
+        path: event.metadata?.path,
+        fileSize: event.metadata?.fileSize,
+        fileName: event.metadata?.fileName,
+        totalChunks: event.metadata?.totalChunks,
+        chunkSize: event.metadata?.chunkSize
+      }
+    }));
+  }
+  async getTideIncomingTransferActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tide:incoming-transfer": "tide:incoming-transfer"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tide-incoming-transfer",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        recipientID: event.metadata?.recipientID,
+        senderID: event.metadata?.senderID,
+        fileSize: event.metadata?.fileSize,
+        fileName: event.metadata?.fileName,
+        path: event.metadata?.path,
+        startedOn: event.metadata?.startedOn
+      }
+    }));
+  }
+  async getTideBarrierAcceptedActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tide-barrier:accepted": "tide-barrier:accepted"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tide-barrier-accepted",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        recipientID: event.metadata?.recipientID,
+        transferID: event.metadata?.transferID,
+        senderID: event.metadata?.senderID,
+        tideItemCount: event.metadata?.tideItemCount,
+        tideItemSize: event.metadata?.tideItemSize,
+        tideTransferContentType: event.metadata?.tideTransferContentType,
+        tideTransferType: event.metadata?.tideTransferType,
+        tideDestinationPath: event.metadata?.tideDestinationPath,
+        tideOriginPath: event.metadata?.tideOriginPath
+      }
+    }));
+  }
+  async getTideBarrierDeniedActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tide-barrier:denied": "tide-barrier:denied"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tide-barrier-denied",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        recipientID: event.metadata?.recipientID,
+        transferID: event.metadata?.transferID,
+        senderID: event.metadata?.senderID,
+        tideItemCount: event.metadata?.tideItemCount,
+        tideItemSize: event.metadata?.tideItemSize,
+        tideTransferContentType: event.metadata?.tideTransferContentType,
+        tideTransferType: event.metadata?.tideTransferType,
+        tideDestinationPath: event.metadata?.tideDestinationPath,
+        tideOriginPath: event.metadata?.tideOriginPath
+      }
+    }));
+  }
+  async getFileListReceivedActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "file-list:received": "file-list:received"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "file-list-received",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        recipientID: event.metadata?.recipientID,
+        senderID: event.metadata?.senderID,
+        totalItems: event.metadata?.totalItems,
+        runningOn: event.metadata?.runningOn
+      }
+    }));
+  }
+  async getFileListRequestActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "file-list:request": "file-list:request"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "file-list-request",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        recipientID: event.metadata?.recipientID,
+        requesterID: event.metadata?.requesterID,
+        depth: event.metadata?.depth
+      }
+    }));
+  }
+  async getTiderBannedActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tider:banned": "tider:banned"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "ban-client-activated",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        clientID: event.metadata?.clientID,
+        options: event.metadata?.options
+      }
+    }));
+  }
+  async getTiderKickedActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tider:kicked": "tider:kicked"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "kick-client-activated",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        clientID: event.metadata?.clientID,
+        options: event.metadata?.options
+      }
+    }));
+  }
+  async getTiderUnbannedActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tider:unbanned": "tider:unbanned"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "unban-client-activated",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        clientID: event.metadata?.clientID
+      }
+    }));
+  }
+  async getTiderAlreadyOnlineActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tider:already-online": "tider:already-online"
+      }
+    });
+    if (!Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tider-already-online",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        currentTideChannel: event.metadata?.currentTideChannel || "file-room",
+        originUser: event.metadata?.originUser,
+        user: event.metadata?.user,
+        connectionID: event.metadata?.connectionID,
+        pClientID: event.metadata?.pClientID,
+        tideID: event.metadata?.tideID,
+        connectedOn: event.metadata?.connectedOn
+      }
+    }));
+  }
+  async getTiderOnlineActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tider:online": "tider:online"
+      }
+    });
+    if (!rawMetrics || !Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tider-online",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        currentTideChannel: event.metadata?.currentTideChannel || "file-room",
+        connectedOn: event.metadata?.connectedOn,
+        originUser: event.metadata?.originUser,
+        user: event.metadata?.user,
+        connectionID: event.metadata?.connectionID,
+        pClientID: event.metadata?.pClientID,
+        tideID: event.metadata?.tideID
+      }
+    }));
+  }
+  async getTiderOfflineActions({
+    interval = "1d",
+    limit = 50,
+    source = "storage",
+    filter = {}
+  } = {}) {
+    const rawMetrics = await this.getTidalyticsSince(interval, source, {
+      ...filter,
+      tags: {
+        "tider:offline": "tider:offline"
+      }
+    });
+    if (!rawMetrics || !Array.isArray(rawMetrics)) {
+      return [];
+    }
+    const limitedMetrics = rawMetrics.slice(-limit).reverse();
+    return limitedMetrics.map(event => ({
+      tideActionID: "tider-offline",
+      tideActionDate: event.timestamp || Date.now(),
+      tideActionDetails: {
+        currentTideChannel: event.metadata?.currentTideChannel || "file-room",
+        connectedOn: event.metadata?.connectedOn,
+        originUser: event.metadata?.originUser,
+        user: event.metadata?.user,
+        connectionID: event.metadata?.connectionID,
+        pClientID: event.metadata?.pClientID,
+        tideID: event.metadata?.tideID
+      }
+    }));
+  }
 
   // --- File Messager Tide Sentinel Management ---
 
@@ -1197,7 +2094,7 @@ class FileMessager {
           currentTideChannel: clientDetails.currentTideChannel || "file-room",
           originUser: clientDetails.originClientID,
           user: clientDetails.clientID,
-          connectionID: clientDetails.connectionID,
+          connectionID: clientData.connectionID,
           pClientID: clientDetails.pClientID,
           tideID: clientDetails.tideID,
           connectedOn: clientDetails.connectedOn
@@ -1210,7 +2107,7 @@ class FileMessager {
           currentTideChannel: clientDetails.currentTideChannel || "file-room",
           originUser: clientDetails.originClientID,
           user: clientDetails.clientID,
-          connectionID: clientDetails.connectionID,
+          connectionID: clientData.connectionID,
           pClientID: clientDetails.pClientID,
           tideID: clientDetails.tideID,
           connectedOn: clientDetails.connectedOn

package/dist/cjs/HUDManagers/TidalyticsUtilityManager.js

@@ -0,0 +1,146 @@
+"use strict";
+
+function getNestedData(obj, path) {
+  return path.split(".").reduce((acc, part) => acc?.[part], obj);
+}
+;
+function pickData(data, keys) {
+  if (!keys) {
+    return data;
+  }
+  return keys.reduce((acc, key) => {
+    if (data[key] !== undefined) {
+      acc[key] = data[key];
+    }
+    return acc;
+  }, {});
+}
+;
+function aggregateMultiAverageChartData(events, {
+  groupBy = ["user"],
+  valueKey = "metadata.fileSize",
+  timestampKey = "timestamp",
+  metadataFields = null,
+  previewLimit = 3
+} = {}) {
+  const buckets = {};
+  for (const event of events) {
+    const labelParts = groupBy.map(path => {
+      if (path === "time") {
+        return event[timestampKey];
+      }
+      if (path === "user") {
+        return event.metadata?.clientID || event.metadata?.senderID || "unknown";
+      }
+      if (path === "type") {
+        return event.type || "unknown";
+      }
+      return getNestedData(event, path) ?? "unknown";
+    });
+    const label = labelParts.join(" | ");
+    const value = getNestedData(event, valueKey);
+    if (typeof value !== "number") {
+      continue;
+    }
+    if (!buckets[label]) {
+      buckets[label] = {
+        previewFileNames: [],
+        previewMetadata: [],
+        timestamps: [],
+        values: [],
+        total: 0,
+        count: 0
+      };
+    }
+    const bucket = buckets[label];
+    bucket.total += value;
+    bucket.count += 1;
+    bucket.values.push(value);
+    bucket.timestamps.push(event[timestampKey]);
+    const fileName = getNestedData(event, "metadata.fileName");
+    if (fileName && bucket.previewFileNames.length < previewLimit) {
+      bucket.previewFileNames.push(fileName);
+    }
+    if (bucket.previewMetadata.length < previewLimit) {
+      bucket.previewMetadata.push(pickData(event.metadata || {}, metadataFields));
+    }
+  }
+  return Object.entries(buckets).map(([label, bucket]) => ({
+    firstTimestamp: Math.min(...bucket.timestamps),
+    lastTimestamp: Math.max(...bucket.timestamps),
+    previewFileNames: bucket.previewFileNames,
+    previewMetadata: bucket.previewMetadata,
+    minValue: Math.min(...bucket.values),
+    maxValue: Math.max(...bucket.values),
+    average: +(total / count).toFixed(2),
+    total: bucket.total,
+    count: bucket.count,
+    label
+  }));
+}
+;
+function aggregateChartData(events, {
+  groupBy = "type",
+  typeKey = "type",
+  userKey = "metadata.clientID",
+  timestampKey = "timestamp",
+  valueKey = "value",
+  mode = "count",
+  metadataFields = null,
+  previewLimit = 3
+} = {}) {
+  const buckets = {};
+  for (const event of events) {
+    let label;
+    if (groupBy === "time") {
+      label = event[timestampKey];
+    } else if (groupBy === "user") {
+      label = getNestedData(event, userKey) || "unknown";
+    } else {
+      label = event[typeKey] || "other";
+    }
+    const type = event[typeKey] || "other";
+    const value = mode === "sum" ? getNestedData(event, valueKey) || 0 : 1;
+    if (!buckets[type]) {
+      buckets[type] = {
+        previewFileNames: [],
+        previewMetadata: [],
+        timestamps: [],
+        values: [],
+        count: 0,
+        total: 0,
+        type
+      };
+    }
+    const bucket = buckets[type];
+    bucket.total += value;
+    bucket.count += 1;
+    bucket.values.push(value);
+    bucket.timestamps.push(event[timestampKey]);
+    const fileName = getNestedData(event, "metadata.fileName");
+    if (fileName && bucket.previewFileNames.length < previewLimit) {
+      bucket.previewFileNames.push(fileName);
+    }
+    if (bucket.previewMetadata.length < previewLimit) {
+      bucket.previewMetadata.push(pickData(event.metadata || {}, metadataFields));
+    }
+  }
+  return Object.entries(buckets).map(([type, bucket]) => ({
+    average: +(bucket.total / bucket.count).toFixed(2),
+    firstTimestamp: Math.min(...bucket.timestamps),
+    lastTimestamp: Math.max(...bucket.timestamps),
+    previewFileNames: bucket.previewFileNames,
+    previewMetadata: bucket.previewMetadata,
+    minValue: Math.min(...bucket.values),
+    maxValue: Math.max(...bucket.values),
+    total: bucket.total,
+    count: bucket.count,
+    label: type,
+    type
+  }));
+}
+module.exports = {
+  aggregateMultiAverageChartData,
+  aggregateChartData,
+  getNestedData
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.66",
+  "version": "0.0.67",
   "description": "Revolutionizing real-time file transfer with seamless, instant communication across any device. Deliver files instantly, regardless of platform, and experience unparalleled speed and control in managing transfers. Elevate your file-sharing capabilities with a tool designed for precision, efficiency, and effortless connectivity.",
   "main": "dist/cjs/FileTide.js",
   "scripts": {
@@ -36,7 +36,7 @@
   "dependencies": {
     "@trap_stevo/iotide": "^0.0.43",
     "@trap_stevo/iotide-client": "^0.0.25",
-    "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.43",
+    "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.48",
     "@trap_stevo/metrictide": "^0.0.3",
     "@trap_stevo/timelyst": "^0.0.5",
     "chalk": "^4.1.2",