aesirx-analytics 1.0.0-alpha.1

package/src/AnalyticsReact/index.js

@@ -0,0 +1,29 @@
+import React, { useState } from 'react';
+
+import { AnalyticsContextProvider } from '../utils/AnalyticsContextProvider';
+import AnalyticsHandle from './handle';
+const AnalyticsReact = ({ pathname }) => {
+  const [eventID, setEventID] = useState();
+  const [UUID, setUUID] = useState();
+  const [eventIDStart, setEventIDStart] = useState();
+  const [UUIDStart, setUUIDStart] = useState();
+  return (
+    <>
+      <AnalyticsContextProvider
+        value={{
+          event_uuid: eventID,
+          visitor_uuid: UUID,
+          event_uuid_start: eventIDStart,
+          visitor_uuid_start: UUIDStart,
+          setEventID: setEventID,
+          setUUID: setUUID,
+          setEventIDStart: setEventIDStart,
+          setUUIDStart: setUUIDStart,
+        }}
+      >
+        <AnalyticsHandle pathname={pathname} />
+      </AnalyticsContextProvider>
+    </>
+  );
+};
+export default AnalyticsReact;

package/src/analytics.js

@@ -0,0 +1,112 @@
+import { endTracker, initTracker, startTracker } from './utils';
+
+const AesirAnalytics = () => {
+  const hook = (_this, method, callback) => {
+    const orig = _this[method];
+
+    return (...args) => {
+      callback.apply(null, args);
+
+      return orig.apply(_this, args);
+    };
+  };
+
+  /* Handle history changes */
+
+  const handlePush = async (url) => {
+    if (!url) return;
+    const { pathname, search, origin } = location;
+    url = `${origin}${pathname}${search}`;
+    const newUrl = url.toString();
+
+    if (newUrl.substring(0, 4) === 'http') {
+      url = '/' + newUrl.split('/').splice(3).join('/');
+    } else {
+      url = newUrl;
+    }
+
+    // if (currentUrl !== currentRef) {
+    //   await initTracker();
+    //   startTracker();
+    // }
+  };
+
+  /* Global */
+
+  if (!window.tracker) {
+    const tracker = (eventValue) => eventValue;
+    tracker.initTracker = initTracker;
+    tracker.startTracker = startTracker;
+
+    window.tracker = tracker;
+  }
+
+  /* Start */
+
+  history.pushState = hook(history, 'pushState', handlePush);
+  history.replaceState = hook(history, 'replaceState', handlePush);
+
+  const envParams = process.env;
+  const hostUrl = envParams.ENDPOINT_ANALYTICS_URL ? envParams.ENDPOINT_ANALYTICS_URL : '';
+
+  const root = hostUrl ? hostUrl.replace(/\/$/, '') : '';
+
+  const update = async () => {
+    if (document.readyState === 'complete') {
+      const responseInit = await initTracker(root);
+      if (responseInit) {
+        responseInit.event_uuid && insertParam('event_uuid', responseInit.event_uuid);
+        insertParam('visitor_uuid', responseInit.visitor_uuid);
+        replaceUrl();
+      }
+      const responseStart = await startTracker(root);
+      if (responseStart) {
+        responseStart.event_uuid && insertParam('event_uuid_start', responseStart.event_uuid);
+        insertParam('visitor_uuid_start', responseStart.visitor_uuid);
+        replaceUrl();
+      }
+    }
+  };
+
+  document.addEventListener('readystatechange', update, true);
+
+  window.addEventListener('beforeunload', async () => {
+    await endTracker(root);
+  });
+
+  update();
+};
+const insertParam = (key, value) => {
+  const url = new URL(window.location.href);
+  url.searchParams.set(key, value);
+  window.history.pushState({ path: url.href }, '', url.href);
+};
+
+const replaceUrl = () => {
+  const urlParams = new URLSearchParams(window.location.search);
+  const event_id = urlParams.get('event_id');
+  const uuid = urlParams.get('uuid');
+
+  let anchors = document.getElementsByTagName('a');
+  for (let i = 0; i < anchors.length; i++) {
+    const eventIdParams = getParameterByName('event_id', anchors[i].href);
+    const uuidParams = getParameterByName('uuid', anchors[i].href);
+    if (anchors[i].href) {
+      const url = new URL(anchors[i].href);
+      !eventIdParams && event_id && url.searchParams.append('event_id', event_id);
+      !uuidParams && uuid && url.searchParams.append('uuid', uuid);
+      anchors[i].href = url.href;
+    }
+  }
+};
+
+const getParameterByName = (name, url = window.location.href) => {
+  name = name.replace(/[[\]]/g, '\\$&');
+  var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),
+    results = regex.exec(url);
+  if (!results) return null;
+  if (!results[2]) return '';
+  return decodeURIComponent(results[2].replace(/\+/g, ' '));
+};
+
+AesirAnalytics();

package/src/index.js

@@ -0,0 +1,2 @@
+export { default as AnalyticsNext } from './AnalyticsNext';
+export { default as AnalyticsReact } from './AnalyticsReact';

package/src/utils/AnalyticsContextProvider.js

@@ -0,0 +1,17 @@
+/*
+ * @copyright   Copyright (C) 2022 AesirX. All rights reserved.
+ * @license     GNU General Public License version 3, see LICENSE.
+ */
+
+import React from 'react';
+export const AnalyticsContext = React.createContext();
+
+export class AnalyticsContextProvider extends React.Component {
+  render() {
+    return (
+      <AnalyticsContext.Provider value={{ ...this.props.value }}>
+        {this.props.children}
+      </AnalyticsContext.Provider>
+    );
+  }
+}

package/src/utils/index.js

@@ -0,0 +1,93 @@
+import axios from 'axios';
+import { trackerService } from './services';
+import Bowser from 'bowser';
+
+const createRequest = (endpoint, task) => {
+  return `${endpoint}/visitor/v1/${task}`;
+};
+const getIpAddress = async () => {
+  const res = await axios.get('https://geolocation-db.com/json/');
+  return res.data.IPv4;
+};
+
+/* FUNCTION */
+const initTracker = async (endpoint, url, referrer, user_agent) => {
+  const { document } = window;
+  const { pathname, search, origin } = location;
+  url = `${origin}${pathname}${search}`;
+  referrer = document.referrer;
+  user_agent = window.navigator.userAgent;
+  const browser = Bowser.parse(window.navigator.userAgent);
+  const browser_name = browser?.browser?.name;
+  const browser_version = browser?.browser?.version;
+  const lang = window.navigator.userLanguage || window.navigator.language;
+  const device = browser?.platform?.model ?? browser?.platform?.type;
+  const domain = `${origin}`;
+  const queryString = window.location.search;
+  const urlParams = new URLSearchParams(queryString);
+  if (!urlParams.get('event_id') && !urlParams.get('uuid')) {
+    let ip = await getIpAddress();
+    const response = await trackerService(createRequest(endpoint, 'init'), {
+      url: url,
+      referrer: referrer,
+      user_agent: user_agent,
+      ip: ip,
+      domain: domain,
+      browser_name: browser_name,
+      browser_version: browser_version,
+      lang: lang,
+      device: device,
+    });
+    return response;
+  }
+};
+
+const startTracker = async (endpoint, event_uuid, visitor_uuid, referrer) => {
+  const { location, document } = window;
+  referrer = referrer
+    ? location.protocol + '//' + location.host + referrer
+    : document.referrer.split('?')[0];
+  const url = location.protocol + '//' + location.host + location.pathname;
+  const queryString = window.location.search;
+  const urlParams = new URLSearchParams(queryString);
+  const responseStart = await trackerService(createRequest(endpoint, 'start'), {
+    ...(urlParams.get('event_uuid') && {
+      event_uuid: urlParams.get('event_uuid'),
+    }),
+    ...(urlParams.get('visitor_uuid') && {
+      visitor_uuid: urlParams.get('visitor_uuid'),
+    }),
+    ...(event_uuid && {
+      event_uuid: event_uuid,
+    }),
+    ...(visitor_uuid && {
+      visitor_uuid: visitor_uuid,
+    }),
+    referrer: referrer === '/' ? '' : referrer,
+    url: url,
+  });
+
+  return responseStart;
+};
+
+const endTracker = async (endpoint, event_uuid, visitor_uuid) => {
+  const queryString = window.location.search;
+  const urlParams = new URLSearchParams(queryString);
+  const responseEnd = await trackerService(createRequest(endpoint, 'end'), {
+    ...(urlParams.get('event_uuid_start') && {
+      event_uuid: urlParams.get('event_uuid_start'),
+    }),
+    ...(urlParams.get('visitor_uuid_start') && {
+      visitor_uuid: urlParams.get('visitor_uuid_start'),
+    }),
+    ...(event_uuid && {
+      event_uuid: event_uuid,
+    }),
+    ...(visitor_uuid && {
+      visitor_uuid: visitor_uuid,
+    }),
+  });
+  return responseEnd;
+};
+
+export { initTracker, startTracker, endTracker };

package/src/utils/services.js

@@ -0,0 +1,20 @@
+/* SERVICES */
+let cache;
+const assign = (a, b) => {
+  Object.keys(b).forEach((key) => {
+    if (b[key] !== undefined) a[key] = b[key];
+  });
+  return a;
+};
+
+const trackerService = async (endpoint, payload) => {
+  const fetchData = await fetch(endpoint, {
+    method: 'POST',
+    body: JSON.stringify(payload),
+    headers: assign({ 'Content-Type': 'application/json' }, { ['x-tracker-cache']: cache }),
+  });
+  const response = await fetchData.json();
+  return response;
+};
+
+export { trackerService };

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "listEmittedFiles": false,
+    "outDir": "dist/lib/types",
+    "declaration": true, 
+    "declarationMap": true,
+    "module": "ESNext",
+    "target": "ES6",
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "removeComments": false,
+    "suppressImplicitAnyIndexErrors": true,
+    "sourceMap": true,
+    "pretty": true,
+    "allowJs": true,
+    "jsx": "react",
+    "lib": [
+      "es2016",
+      "dom"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "./node_modules/**/*",
+    "./dist/**/*",
+    "./src/analytics.js",
+  ],
+}