iidrak-analytics-react 1.2.4

package/metastreamio/metastreamio.logger.js

@@ -0,0 +1,150 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+
+strf();
+
+/*
+ *
+ * Console logger
+ *
+ */
+
+class MetaStreamIOLogger {
+  constructor({
+    constants,
+    logPrefix,
+    loggingEnabled = false,
+    loggingLevel = "INFO",
+    loggingCategories = null,
+    loggingAlwaysWarn = true,
+    loggingAlwaysError = true,
+  } = {}) {
+    this.constant = constants;
+    this.logPrefix = logPrefix ? logPrefix : "";
+    this.loggingEnabled = loggingEnabled;
+    this.loggingCategories = loggingCategories;
+
+    this.level = { info: 1, warn: 2, error: 3 };
+
+    this.loggingLevel = this.enumLevel(loggingLevel);
+
+    this.alwaysWarn = loggingAlwaysWarn;
+    this.alwaysError = loggingAlwaysError;
+  }
+
+  enumLevel(level) {
+    switch (level) {
+      case "INFO":
+        return this.level.info;
+        break;
+      case "WARN":
+        return this.level.warn;
+        break;
+      case "ERROR":
+        return this.level.error;
+        break;
+      default:
+        return this.level.info;
+    }
+  }
+
+  checkCategory(category = null) {
+    if (
+      this.loggingCategories !== null &&
+      this.loggingCategories.length === 0
+    ) {
+      return true;
+    }
+    if (!Array.isArray(category)) {
+      category = [category];
+    }
+    for (let cat in category) {
+      if (category[cat] === null) {
+        return true;
+      } else if (
+        this.loggingCategories === null ||
+        this.loggingCategories === undefined
+      ) {
+        return true;
+      } else if (this.loggingCategories.includes(category[cat])) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  log(category = null, ...messages) {
+    if (
+      this.loggingEnabled == true &&
+      this.loggingLevel <= this.level.info &&
+      this.checkCategory(category)
+    ) {
+      console.log(this.logPrefix, `<${category}>`, messages.join(" "));
+      return true;
+    }
+  }
+  log_unformatted(category = null, ...messages) {
+    if (
+      this.loggingEnabled == true &&
+      this.loggingLevel <= this.level.info &&
+      this.checkCategory(category)
+    ) {
+      console.log(messages.join(" "));
+      return true;
+    }
+  }
+  json(category = null, data) {
+    if (
+      this.loggingEnabled == true &&
+      this.loggingLevel <= this.level.info &&
+      this.checkCategory(category)
+    ) {
+      console.log(this.logPrefix, `<${category}>`);
+      console.log(JSON.stringify(data, null, 4));
+      return true;
+    }
+  }
+  info(category = null, ...messages) {
+    if (
+      this.loggingEnabled == true &&
+      this.loggingLevel <= this.level.info &&
+      this.checkCategory(category)
+    ) {
+      console.log(this.logPrefix, `<${category}>`, messages.join(" "));
+      return true;
+    }
+  }
+  warn(category = null, ...messages) {
+    if (this.loggingEnabled && this.alwaysWarn) {
+      this._warn(category, messages);
+    } else if (
+      this.loggingEnabled == true &&
+      this.loggingLevel <= this.level.warn
+    ) {
+      this._warn(category, messages);
+      return true;
+    }
+  }
+  _warn(category, messages) {
+    console.warn(this.logPrefix, `<${category}>`, messages.join(" "));
+  }
+  error(category = null, ...messages) {
+    if (this.loggingEnabled && this.alwaysError) {
+      this._error(category, messages);
+      return true;
+    } else if (
+      this.loggingEnabled == true &&
+      this.loggingLevel <= this.level.error
+    ) {
+      this._error(category, messages);
+      return true;
+    }
+  }
+  _error(category, messages) {
+    console.error(this.logPrefix, `<${category}>`, messages.join(" "));
+  }
+}
+
+export { MetaStreamIOLogger };

package/metastreamio/metastreamio.network.js

@@ -0,0 +1,313 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import NetInfo from "@react-native-community/netinfo";
+
+strf();
+
+const EVENT_QUEUE_KEY = "metastream_offline_events";
+
+/*
+ *
+ * Network functions
+ *
+ */
+
+class MetaStreamIONetwork {
+  constructor({ constants, endpoints, logger, silentMode, headers } = {}) {
+    this.silentMode = silentMode;
+    this.constant = constants;
+    this.endpoint = null;
+    this.endpoints = Array.isArray(endpoints) ? endpoints : [];
+    this.headers = headers;
+    this.logger = logger;
+
+    // Initialize offline handling
+    this.initOfflineHandling();
+  }
+
+  initOfflineHandling() {
+    // Flush on startup if connected
+    NetInfo.fetch().then(state => {
+      if (state.isConnected) {
+        this.flushEvents();
+      }
+    });
+
+    // Flush when network comes back online
+    NetInfo.addEventListener(state => {
+      if (state.isConnected) {
+        this.flushEvents();
+      }
+    });
+  }
+
+  reset() {
+    this.endpoint = null;
+  }
+
+  async testConnection() {
+    if (!this.endpoint || this.endpoint === null) {
+      for (let _e in this.endpoints) {
+        this.endpoint = await this.getData({ endpoint: this.endpoints[_e] })
+          .then((data) => {
+            try {
+              if (data.status === 200) {
+                return this.endpoints[_e];
+              }
+            } catch (err) {
+              return false;
+            }
+          })
+          .catch(() => { });
+        if (this.endpoint) {
+          this.logger.log(
+            "network",
+            this.constant.MetaStreamIO_Network_EndpointSet.format(this.endpoint)
+          );
+          break;
+        } else {
+          this.logger.log(
+            "network",
+            this.constant.MetaStreamIO_Network_EndpointTestFailed.format(
+              this.endpoint
+            )
+          );
+          this.logger.log(
+            "network",
+            this.constant.MetaStreamIO_Network_SilentModeEnabled
+          );
+        }
+      }
+    }
+
+    return Promise.resolve(this.endpoint);
+  }
+
+  async getData({ endpoint = this.endpoint } = {}) {
+    var rx;
+
+    let get_config = {
+      method: "GET",
+      // mode: "no-cors", // required for local testing
+      cache: "no-cache",
+      credentials: "same-origin",
+      redirect: "follow", // manual, *follow, error
+      referrerPolicy: "no-referrer", // no-referrer, *client
+      headers: {},
+    };
+
+    if (this.headers !== null) {
+      get_config.headers = Object.assign(get_config.headers, this.headers);
+    }
+
+    try {
+      await fetch(endpoint, get_config)
+        .then((response) => {
+          const contentType = response.headers.get("content-type");
+          if (!contentType || !contentType.includes("application/json")) {
+            return null;
+          } else {
+            return response;
+          }
+        })
+        .catch((err) => {
+          return Promise.resolve(err);
+        })
+        .then(async (response) => {
+          rx = {
+            body: await response.json(),
+            status: response.status,
+          };
+        })
+        .catch((err) => {
+          return {
+            body: err,
+            status: 400,
+          };
+        });
+      return rx;
+    } catch (err) {
+      return Promise.reject(err);
+      throw this.constant.MetaStreamIO_Network_GetDataIssue.format(
+        err,
+        endpoint
+      );
+    }
+  }
+
+  async postData({ data = {}, endpoint = null } = {}) {
+    var ret;
+
+    var _endpoint = this.endpoint + (endpoint ? endpoint : "");
+
+    this.logger.log(
+      "network-request",
+      this.constant.MetaStreamIO_Log_RequestObject
+    );
+    this.logger.json("network-request", data);
+
+    if (this.silentMode) {
+      return {
+        body: this.constant.MetaStreamIO_Network_SilentMode,
+        status: 1,
+      };
+    }
+
+    if (!this.endpoint) {
+      _endpoint = await this.testConnection()
+        .then((rx_endpoint) => {
+          return Promise.resolve(rx_endpoint + (endpoint ? endpoint : ""));
+        })
+        .catch((err) => err);
+    }
+
+    if (_endpoint) {
+      return await this.post({
+        data: data,
+        endpoint: _endpoint,
+      })
+        .then((post_return) => {
+          return Promise.resolve(post_return);
+        })
+        .catch((err) => {
+          return Promise.resolve(err);
+        });
+    } else {
+      // Network configuration failed, try to store offline if it looks like a network issue
+      this.logger.log("network", "No endpoint resolved, storing offline...");
+      // Use the first endpoint candidate if available for offline storage purpose
+      const fallbackEndpoint = this.endpoints.length > 0 ? this.endpoints[0] : null;
+      if (fallbackEndpoint) {
+        await this.storeOfflineEvent(fallbackEndpoint + (endpoint ? endpoint : ""), data);
+        return {
+          body: "Stored offline",
+          status: 200 // Fake success to prevent app error
+        };
+      }
+
+      return {
+        body: this.constant.MetaStreamIO_Network_PostDataIssue.format(
+          "attempted to reset network",
+          _endpoint
+        ),
+        status: 400,
+      };
+    }
+  }
+
+  async post({ data = {}, endpoint = this.endpoint } = {}) {
+    let rx = {};
+
+    let post_config = {
+      method: "POST",
+      // mode: "no-cors", // required for local testing
+      cache: "no-cache",
+      credentials: "same-origin",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      redirect: "follow", // manual, *follow, error
+      referrerPolicy: "no-referrer", // no-referrer, *client
+      body: JSON.stringify(data),
+    };
+
+    if (this.headers !== null) {
+      post_config.headers = Object.assign(post_config.headers, this.headers);
+    }
+
+    let isOffline = false;
+    await NetInfo.fetch().then(state => {
+      if (!state.isConnected) {
+        isOffline = true;
+      }
+    });
+
+    if (isOffline) {
+      this.logger.log("network", "Offline detected. Storing event.");
+      await this.storeOfflineEvent(endpoint, data);
+      return { status: 200, body: "Stored offline" };
+    }
+
+    await fetch(endpoint, post_config)
+      .then((response) => {
+        let _contentType = response.headers.get("content-type");
+        if (!_contentType || !_contentType.includes("application/json")) {
+          return null;
+        } else {
+          rx.status = response.status;
+          return response;
+        }
+      })
+      .then(async (response) => {
+        rx.body = await response.json();
+      })
+      .catch(async (err) => {
+        this.logger.error("network", "fetch() response", err);
+        // Store offline on network error
+        await this.storeOfflineEvent(endpoint, data);
+        rx.status = 200; // Treat as success to deque
+        rx.body = "Stored offline on error";
+      });
+
+    return rx;
+  }
+
+  async storeOfflineEvent(endpoint, payload) {
+    try {
+      const existing = JSON.parse(await AsyncStorage.getItem(EVENT_QUEUE_KEY)) || [];
+      const newEvent = {
+        endpoint,
+        payload,
+        failedAt: new Date().toISOString(),
+      };
+      existing.push(newEvent);
+      await AsyncStorage.setItem(EVENT_QUEUE_KEY, JSON.stringify(existing));
+      this.logger.log("network", `Stored event locally. Queue size: ${existing.length}`);
+    } catch (error) {
+      this.logger.error("network", "Failed to store event:", error);
+    }
+  }
+
+  async flushEvents() {
+    try {
+      const stored = JSON.parse(await AsyncStorage.getItem(EVENT_QUEUE_KEY)) || [];
+      if (stored.length === 0) {
+        return;
+      }
+
+      this.logger.log("network", `Flushing ${stored.length} stored event(s)...`);
+      const remainingEvents = [];
+
+      for (const e of stored) {
+        try {
+          const response = await fetch(e.endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(e.payload),
+          });
+
+          if (response.ok) {
+            this.logger.log("network", "Retried & sent event");
+          } else {
+            // Drop event if server rejects it (4xx, 5xx), avoid infinite loop
+            this.logger.warn("network", "Retry failed with non-OK status, dropping event");
+          }
+        } catch (err) {
+          // Keep if network error
+          remainingEvents.push(e);
+        }
+      }
+
+      await AsyncStorage.setItem(EVENT_QUEUE_KEY, JSON.stringify(remainingEvents));
+      if (remainingEvents.length < stored.length) {
+        this.logger.log("network", `Flush complete. Remaining: ${remainingEvents.length}`);
+      }
+    } catch (error) {
+      this.logger.error("network", "Failed to flush events:", error);
+    }
+  }
+
+}
+export { MetaStreamIONetwork };

package/metastreamio/metastreamio.provider.js

@@ -0,0 +1,50 @@
+import React, { Component } from 'react';
+import { View, StyleSheet, Dimensions } from 'react-native';
+import ViewShot from 'react-native-view-shot';
+
+class MetaStreamProvider extends Component {
+    constructor(props) {
+        super(props);
+        this.viewShotRef = React.createRef();
+        this.tracker = props.tracker;
+
+        // Auto-start recording if tracker is available
+        if (this.tracker && this.tracker.recorder) {
+            // Small delay to ensure view is mounted
+            setTimeout(() => {
+                this.tracker.recorder.startRecording(this.viewShotRef);
+            }, 1000);
+        }
+    }
+
+    handleTouch(e, type) {
+        if (this.tracker && this.tracker.recorder) {
+            this.tracker.recorder.recordInteraction(type, e.nativeEvent);
+        }
+    }
+
+    render() {
+        const { children, style } = this.props;
+
+        return (
+            <ViewShot ref={this.viewShotRef} style={{ flex: 1 }} options={{ format: "jpg", quality: 0.5 }}>
+                <View
+                    style={[styles.container, style]}
+                    onTouchStart={(e) => this.handleTouch(e, 'touch_start')}
+                    onTouchMove={(e) => this.handleTouch(e, 'touch_move')}
+                    onTouchEnd={(e) => this.handleTouch(e, 'touch_end')}
+                >
+                    {children}
+                </View>
+            </ViewShot>
+        );
+    }
+}
+
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+    }
+});
+
+export { MetaStreamProvider };

package/metastreamio/metastreamio.queue.js

@@ -0,0 +1,68 @@
+// http://nickang.com
+
+/**
+ * Implementation of Queue.
+ */
+class Queue {
+  /**
+   * Create a queue.
+   */
+  constructor() {
+    this.store = {};
+    this.front = 0;
+    this.end = 0;
+  }
+}
+
+/**
+ * Add item to end of queue.
+ * @param {*} The data to store in the position.
+ */
+Queue.prototype.enqueue = function (data) {
+  this.store[this.end] = data;
+  this.end++;
+};
+
+/**
+ * Remove item from queue and return its data.
+ * @return {*} The data stored in item.
+ */
+Queue.prototype.dequeue = function () {
+  if (this.front === this.end) return null;
+
+  const data = this.store[this.front];
+  delete this.store[this.front];
+  this.front++;
+  return data;
+};
+
+/**
+ * Return current size of queue.
+ * @return {number} Size of queue.
+ */
+Queue.prototype.size = function () {
+  return this.end - this.front;
+};
+
+/**
+ * Return item at front of queue without dequeueing.
+ * @return {*} The data stored in item.
+ */
+Queue.prototype.peek = function () {
+  if (this.size() === 0) return null;
+  return this.store[this.front];
+};
+
+/*
+ * The MetaStreamIO SAUCE
+ *
+ */
+Queue.prototype.run = function (callback) {
+  while (this.size() > 0) {
+    callback(this.dequeue()).catch(err => {
+      console.error('<queue callback>', err);
+    });
+  }
+};
+
+export {Queue};