trackfox-electron 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,235 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  TrackFox: () => TrackFox
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/detection.ts
+var import_os = __toESM(require("os"), 1);
+function getElectronInfo(app, screen) {
+  const primaryDisplay = screen.getPrimaryDisplay();
+  return {
+    appVersion: app.getVersion(),
+    electronVersion: process.versions.electron ?? "unknown",
+    nodeVersion: process.versions.node,
+    platform: process.platform,
+    arch: process.arch,
+    osRelease: import_os.default.release(),
+    screenResolution: {
+      width: primaryDisplay.size.width,
+      height: primaryDisplay.size.height
+    },
+    locale: app.getLocale(),
+    isPackaged: app.isPackaged
+  };
+}
+
+// src/session.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var SESSION_TTL_MS = 30 * 60 * 1e3;
+function generateId(prefix = "") {
+  const hex = () => Math.floor(Math.random() * 16).toString(16);
+  const uuid = `${prefix}xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`.replace(/[xy]/g, (c) => {
+    const r = Math.floor(Math.random() * 16);
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+  return uuid;
+}
+function loadOrCreateSession(userDataPath) {
+  const storePath = import_path.default.join(userDataPath, "trackfox.json");
+  let store = {};
+  try {
+    if (import_fs.default.existsSync(storePath)) {
+      store = JSON.parse(import_fs.default.readFileSync(storePath, "utf-8"));
+    }
+  } catch {
+    store = {};
+  }
+  const now = Date.now();
+  const visitorId = store.visitorId ?? generateId();
+  const sessionExpired = !store.sessionId || !store.sessionExpiry || now > store.sessionExpiry;
+  const sessionId = sessionExpired ? generateId("s") : store.sessionId;
+  const sessionExpiry = now + SESSION_TTL_MS;
+  const updated = { visitorId, sessionId, sessionExpiry };
+  try {
+    import_fs.default.writeFileSync(storePath, JSON.stringify(updated), "utf-8");
+  } catch {
+  }
+  return { visitorId, sessionId };
+}
+function refreshSession(userDataPath, sessionId) {
+  const storePath = import_path.default.join(userDataPath, "trackfox.json");
+  try {
+    const raw = import_fs.default.readFileSync(storePath, "utf-8");
+    const store = JSON.parse(raw);
+    if (store.sessionId === sessionId) {
+      store.sessionExpiry = Date.now() + SESSION_TTL_MS;
+      import_fs.default.writeFileSync(storePath, JSON.stringify(store), "utf-8");
+    }
+  } catch {
+  }
+}
+
+// src/queue.ts
+var EventQueue = class {
+  constructor(flushFn) {
+    this.queue = [];
+    this.online = true;
+    this.flush = flushFn;
+  }
+  setOnline(isOnline) {
+    const wasOffline = !this.online;
+    this.online = isOnline;
+    if (isOnline && wasOffline) {
+      this.drainQueue();
+    }
+  }
+  async enqueue(payload) {
+    if (this.online) {
+      try {
+        await this.flush(payload);
+      } catch (err) {
+        console.error("[TrackFox] send failed, queuing for retry:", err);
+        this.queue.push(payload);
+      }
+    } else {
+      this.queue.push(payload);
+    }
+  }
+  async drainQueue() {
+    const pending = this.queue.splice(0);
+    for (const payload of pending) {
+      try {
+        await this.flush(payload);
+      } catch (err) {
+        console.error("[TrackFox] retry failed:", err);
+        this.queue.unshift(payload);
+        break;
+      }
+    }
+  }
+};
+
+// src/tracker.ts
+var TrackFoxTracker = class {
+  constructor() {
+    this.options = null;
+    this.electronInfo = null;
+    this.visitorId = "";
+    this.sessionId = "";
+    this.userDataPath = "";
+    this.queue = null;
+  }
+  init(opts, app, screen, ipcMain) {
+    this.options = {
+      apiUrl: "https://trackfox.app",
+      debug: false,
+      ...opts
+    };
+    this.userDataPath = app.getPath("userData");
+    this.electronInfo = getElectronInfo(app, screen);
+    const session = loadOrCreateSession(this.userDataPath);
+    this.visitorId = session.visitorId;
+    this.sessionId = session.sessionId;
+    this.queue = new EventQueue((payload) => this.send(payload));
+    if (ipcMain) {
+      ipcMain.on("trackfox:event", (_e, { eventName, data }) => {
+        this.trackEvent(eventName, data);
+      });
+    }
+  }
+  trackView(screenName) {
+    this.enqueue("appview", screenName);
+  }
+  trackEvent(eventName, data) {
+    this.enqueue("app_event", eventName, { eventName, ...data });
+  }
+  trackRevenue(data) {
+    this.enqueue("app_event", "payment", { eventName: "payment", ...data });
+  }
+  enqueue(type, href, extraData) {
+    if (!this.options || !this.electronInfo || !this.queue) {
+      if (this.options?.debug) console.warn("[TrackFox] SDK not initialized \u2014 call TrackFox.init() first");
+      return;
+    }
+    refreshSession(this.userDataPath, this.sessionId);
+    const payload = {
+      type,
+      websiteId: this.options.websiteId,
+      domain: this.options.domain,
+      href,
+      referrer: null,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      viewport: null,
+      visitorId: this.visitorId,
+      sessionId: this.sessionId,
+      language: this.electronInfo.locale,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      electronInfo: this.electronInfo,
+      extraData
+    };
+    if (this.options.debug) console.log("[TrackFox]", payload);
+    this.queue.enqueue(payload);
+  }
+  async send(payload) {
+    const url = `${this.options.apiUrl}/api/events`;
+    let fetchFn;
+    try {
+      const { net } = await import("electron");
+      fetchFn = net.fetch.bind(net);
+    } catch {
+      fetchFn = fetch;
+    }
+    const response = await fetchFn(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "accept": "application/json",
+        "accept-language": "en-US,en;q=0.9",
+        "accept-encoding": "gzip, deflate, br"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`TrackFox: HTTP ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    }
+    if (this.options?.debug) console.log("[TrackFox] event sent:", payload.type, payload.href);
+  }
+};
+var TrackFox = new TrackFoxTracker();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrackFox
+});

package/dist/index.d.cts

@@ -0,0 +1,63 @@
+import { App, Screen, IpcMain } from 'electron';
+
+interface TrackFoxOptions {
+    websiteId: string;
+    domain: string;
+    apiUrl?: string;
+    debug?: boolean;
+}
+interface ElectronInfo {
+    appVersion: string;
+    electronVersion: string;
+    nodeVersion: string;
+    platform: string;
+    arch: string;
+    osRelease: string;
+    screenResolution?: {
+        width: number;
+        height: number;
+    };
+    locale: string;
+    isPackaged: boolean;
+}
+interface RevenueData {
+    email: string;
+    amnt: number;
+    currency?: string;
+    orderId?: string;
+    productId?: string;
+    category?: string;
+}
+interface EventPayload {
+    type: string;
+    websiteId: string;
+    domain: string;
+    href: string;
+    referrer: null;
+    timestamp: string;
+    viewport: null;
+    visitorId: string;
+    sessionId: string;
+    language: string;
+    timezone: string;
+    electronInfo: ElectronInfo;
+    extraData?: Record<string, unknown>;
+}
+
+declare class TrackFoxTracker {
+    private options;
+    private electronInfo;
+    private visitorId;
+    private sessionId;
+    private userDataPath;
+    private queue;
+    init(opts: TrackFoxOptions, app: App, screen: Screen, ipcMain?: IpcMain): void;
+    trackView(screenName: string): void;
+    trackEvent(eventName: string, data?: Record<string, unknown>): void;
+    trackRevenue(data: RevenueData): void;
+    private enqueue;
+    private send;
+}
+declare const TrackFox: TrackFoxTracker;
+
+export { type ElectronInfo, type EventPayload, type RevenueData, TrackFox, type TrackFoxOptions };

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+import { App, Screen, IpcMain } from 'electron';
+
+interface TrackFoxOptions {
+    websiteId: string;
+    domain: string;
+    apiUrl?: string;
+    debug?: boolean;
+}
+interface ElectronInfo {
+    appVersion: string;
+    electronVersion: string;
+    nodeVersion: string;
+    platform: string;
+    arch: string;
+    osRelease: string;
+    screenResolution?: {
+        width: number;
+        height: number;
+    };
+    locale: string;
+    isPackaged: boolean;
+}
+interface RevenueData {
+    email: string;
+    amnt: number;
+    currency?: string;
+    orderId?: string;
+    productId?: string;
+    category?: string;
+}
+interface EventPayload {
+    type: string;
+    websiteId: string;
+    domain: string;
+    href: string;
+    referrer: null;
+    timestamp: string;
+    viewport: null;
+    visitorId: string;
+    sessionId: string;
+    language: string;
+    timezone: string;
+    electronInfo: ElectronInfo;
+    extraData?: Record<string, unknown>;
+}
+
+declare class TrackFoxTracker {
+    private options;
+    private electronInfo;
+    private visitorId;
+    private sessionId;
+    private userDataPath;
+    private queue;
+    init(opts: TrackFoxOptions, app: App, screen: Screen, ipcMain?: IpcMain): void;
+    trackView(screenName: string): void;
+    trackEvent(eventName: string, data?: Record<string, unknown>): void;
+    trackRevenue(data: RevenueData): void;
+    private enqueue;
+    private send;
+}
+declare const TrackFox: TrackFoxTracker;
+
+export { type ElectronInfo, type EventPayload, type RevenueData, TrackFox, type TrackFoxOptions };

package/dist/index.js

@@ -0,0 +1,198 @@
+// src/detection.ts
+import os from "os";
+function getElectronInfo(app, screen) {
+  const primaryDisplay = screen.getPrimaryDisplay();
+  return {
+    appVersion: app.getVersion(),
+    electronVersion: process.versions.electron ?? "unknown",
+    nodeVersion: process.versions.node,
+    platform: process.platform,
+    arch: process.arch,
+    osRelease: os.release(),
+    screenResolution: {
+      width: primaryDisplay.size.width,
+      height: primaryDisplay.size.height
+    },
+    locale: app.getLocale(),
+    isPackaged: app.isPackaged
+  };
+}
+
+// src/session.ts
+import fs from "fs";
+import path from "path";
+var SESSION_TTL_MS = 30 * 60 * 1e3;
+function generateId(prefix = "") {
+  const hex = () => Math.floor(Math.random() * 16).toString(16);
+  const uuid = `${prefix}xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`.replace(/[xy]/g, (c) => {
+    const r = Math.floor(Math.random() * 16);
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+  return uuid;
+}
+function loadOrCreateSession(userDataPath) {
+  const storePath = path.join(userDataPath, "trackfox.json");
+  let store = {};
+  try {
+    if (fs.existsSync(storePath)) {
+      store = JSON.parse(fs.readFileSync(storePath, "utf-8"));
+    }
+  } catch {
+    store = {};
+  }
+  const now = Date.now();
+  const visitorId = store.visitorId ?? generateId();
+  const sessionExpired = !store.sessionId || !store.sessionExpiry || now > store.sessionExpiry;
+  const sessionId = sessionExpired ? generateId("s") : store.sessionId;
+  const sessionExpiry = now + SESSION_TTL_MS;
+  const updated = { visitorId, sessionId, sessionExpiry };
+  try {
+    fs.writeFileSync(storePath, JSON.stringify(updated), "utf-8");
+  } catch {
+  }
+  return { visitorId, sessionId };
+}
+function refreshSession(userDataPath, sessionId) {
+  const storePath = path.join(userDataPath, "trackfox.json");
+  try {
+    const raw = fs.readFileSync(storePath, "utf-8");
+    const store = JSON.parse(raw);
+    if (store.sessionId === sessionId) {
+      store.sessionExpiry = Date.now() + SESSION_TTL_MS;
+      fs.writeFileSync(storePath, JSON.stringify(store), "utf-8");
+    }
+  } catch {
+  }
+}
+
+// src/queue.ts
+var EventQueue = class {
+  constructor(flushFn) {
+    this.queue = [];
+    this.online = true;
+    this.flush = flushFn;
+  }
+  setOnline(isOnline) {
+    const wasOffline = !this.online;
+    this.online = isOnline;
+    if (isOnline && wasOffline) {
+      this.drainQueue();
+    }
+  }
+  async enqueue(payload) {
+    if (this.online) {
+      try {
+        await this.flush(payload);
+      } catch (err) {
+        console.error("[TrackFox] send failed, queuing for retry:", err);
+        this.queue.push(payload);
+      }
+    } else {
+      this.queue.push(payload);
+    }
+  }
+  async drainQueue() {
+    const pending = this.queue.splice(0);
+    for (const payload of pending) {
+      try {
+        await this.flush(payload);
+      } catch (err) {
+        console.error("[TrackFox] retry failed:", err);
+        this.queue.unshift(payload);
+        break;
+      }
+    }
+  }
+};
+
+// src/tracker.ts
+var TrackFoxTracker = class {
+  constructor() {
+    this.options = null;
+    this.electronInfo = null;
+    this.visitorId = "";
+    this.sessionId = "";
+    this.userDataPath = "";
+    this.queue = null;
+  }
+  init(opts, app, screen, ipcMain) {
+    this.options = {
+      apiUrl: "https://trackfox.app",
+      debug: false,
+      ...opts
+    };
+    this.userDataPath = app.getPath("userData");
+    this.electronInfo = getElectronInfo(app, screen);
+    const session = loadOrCreateSession(this.userDataPath);
+    this.visitorId = session.visitorId;
+    this.sessionId = session.sessionId;
+    this.queue = new EventQueue((payload) => this.send(payload));
+    if (ipcMain) {
+      ipcMain.on("trackfox:event", (_e, { eventName, data }) => {
+        this.trackEvent(eventName, data);
+      });
+    }
+  }
+  trackView(screenName) {
+    this.enqueue("appview", screenName);
+  }
+  trackEvent(eventName, data) {
+    this.enqueue("app_event", eventName, { eventName, ...data });
+  }
+  trackRevenue(data) {
+    this.enqueue("app_event", "payment", { eventName: "payment", ...data });
+  }
+  enqueue(type, href, extraData) {
+    if (!this.options || !this.electronInfo || !this.queue) {
+      if (this.options?.debug) console.warn("[TrackFox] SDK not initialized \u2014 call TrackFox.init() first");
+      return;
+    }
+    refreshSession(this.userDataPath, this.sessionId);
+    const payload = {
+      type,
+      websiteId: this.options.websiteId,
+      domain: this.options.domain,
+      href,
+      referrer: null,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      viewport: null,
+      visitorId: this.visitorId,
+      sessionId: this.sessionId,
+      language: this.electronInfo.locale,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      electronInfo: this.electronInfo,
+      extraData
+    };
+    if (this.options.debug) console.log("[TrackFox]", payload);
+    this.queue.enqueue(payload);
+  }
+  async send(payload) {
+    const url = `${this.options.apiUrl}/api/events`;
+    let fetchFn;
+    try {
+      const { net } = await import("electron");
+      fetchFn = net.fetch.bind(net);
+    } catch {
+      fetchFn = fetch;
+    }
+    const response = await fetchFn(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "accept": "application/json",
+        "accept-language": "en-US,en;q=0.9",
+        "accept-encoding": "gzip, deflate, br"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`TrackFox: HTTP ${response.status}${body ? ` \u2014 ${body}` : ""}`);
+    }
+    if (this.options?.debug) console.log("[TrackFox] event sent:", payload.type, payload.href);
+  }
+};
+var TrackFox = new TrackFoxTracker();
+export {
+  TrackFox
+};

package/dist/preload.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/preload.ts
+var preload_exports = {};
+__export(preload_exports, {
+  exposeToRenderer: () => exposeToRenderer
+});
+module.exports = __toCommonJS(preload_exports);
+var import_electron = require("electron");
+function exposeToRenderer() {
+  import_electron.contextBridge.exposeInMainWorld("trackfox", (eventName, data) => {
+    import_electron.ipcRenderer.send("trackfox:event", { eventName, data });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exposeToRenderer
+});

package/dist/preload.d.cts

@@ -0,0 +1,3 @@
+declare function exposeToRenderer(): void;
+
+export { exposeToRenderer };

package/dist/preload.d.ts

@@ -0,0 +1,3 @@
+declare function exposeToRenderer(): void;
+
+export { exposeToRenderer };

package/dist/preload.js

@@ -0,0 +1,10 @@
+// src/preload.ts
+import { contextBridge, ipcRenderer } from "electron";
+function exposeToRenderer() {
+  contextBridge.exposeInMainWorld("trackfox", (eventName, data) => {
+    ipcRenderer.send("trackfox:event", { eventName, data });
+  });
+}
+export {
+  exposeToRenderer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackfox-electron",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "TrackFox Analytics SDK for Electron desktop apps",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,8 @@
   ],
   "scripts": {
     "build": "tsup",
-    "dev": "tsup --watch"
+    "dev": "tsup --watch",
+    "prepublishOnly": "tsup"
   },
   "keywords": [
     "trackfox",