@ordersune/crm-web-sdk 1.0.6

package/LICENSE

@@ -0,0 +1 @@
+MIT License

package/README.md

@@ -0,0 +1,131 @@
+# Order Sune CRM TypeScript SDK
+
+A powerful TypeScript SDK for integrating the Order Sune CRM solution into your web applications. Enables seamless user tracking, event monitoring, and customer data management.
+
+## Installation
+
+```bash
+npm install @ordersune/crm-web-sdk
+# or
+yarn add @ordersune/crm-web-sdk
+```
+
+## Usage
+
+### Initialize the SDK
+
+```typescript
+import { WebSDK } from '@ordersune/crm-web-sdk';
+
+const crm = new WebSDK({
+  apiKey: 'your-api-key',
+  endpoint: 'https://api.example.com',
+  debug: false 
+});
+```
+
+### User Identification
+
+Identify and track users with custom traits:
+
+```typescript
+// Identify a registered user
+crm.identify('user123', {
+  email: 'user@example.com',
+  name: 'John Doe',
+  subscription: 'premium'
+});
+
+// Get current user profile
+const userProfile = crm.getUserProfile();
+```
+
+### Event Tracking
+
+Track user events with custom properties:
+
+```typescript
+// Basic event tracking
+crm.trackEvent('page_view');
+
+// Event with properties
+crm.trackEvent('purchase_completed', {
+  productId: 'prod_123',
+  amount: 99.99,
+  currency: 'USD'
+});
+
+// Event with custom options
+crm.trackEvent('custom_event', 
+  { key: 'value' },
+  { 
+    timestamp: '2024-12-28T10:00:00Z',
+    requestId: 'req_abc123'
+  }
+);
+```
+
+### Custom Attributes
+
+Track persistent user attributes:
+
+```typescript
+crm.trackCustomAttribute('preference_theme', 'dark');
+crm.trackCustomAttribute('notification_enabled', true);
+```
+
+## Types
+
+### SDKConfig
+
+```typescript
+interface SDKConfig {
+  apiKey: string;      // Your API key
+  endpoint: string;    // API endpoint URL
+  debug?: boolean;     // Enable debug logging
+}
+```
+
+### UserProfile
+
+```typescript
+interface UserProfile {
+  id: string;                    // User identifier
+  user_type: string;             // 'registered' or 'guest'
+  traits: Record<string, any>;   // Custom user traits
+}
+```
+
+### EventOptions
+
+```typescript
+interface EventOptions {
+  timestamp?: string;    // Custom event timestamp
+  requestId?: string;    // Custom request identifier
+}
+```
+
+## Features
+
+- Automatic session tracking
+- Device and browser detection
+- Batch event processing
+- Offline event queuing
+- TypeScript support with full type definitions
+- Debug mode for development
+
+## Requirements
+
+- TypeScript 5.0+
+- Modern browser environment with localStorage support
+- Stable internet connection for event sending
+
+## License
+
+MIT License
+
+For detailed API documentation and examples, visit our [documentation site](https://docs.ordersune.com/crm).
+
+---
+
+Need help? [Contact Support](mailto:support@ordersune.com)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { WebSDK } from "./web-sdk";
+export type { SDKConfig, EventOptions, UserProfile } from "./types";

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSDK = void 0;
+var web_sdk_1 = require("./web-sdk");
+Object.defineProperty(exports, "WebSDK", { enumerable: true, get: function () { return web_sdk_1.WebSDK; } });

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export interface UserProfile {
+    id: string;
+    user_type: string;
+    traits: Record<string, any>;
+}
+export interface EventOptions {
+    timestamp?: string;
+    requestId?: string;
+}
+export interface SDKConfig {
+    apiKey: string;
+    endpoint: string;
+    debug?: boolean;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export declare const log: (debug: boolean, message: string, ...args: any[]) => void;

package/dist/utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+const log = (debug, message, ...args) => {
+    if (debug) {
+        console.log(`[OrderSune CRM]`, message, ...args);
+    }
+};
+exports.log = log;

package/dist/web-sdk.d.ts

@@ -0,0 +1,32 @@
+import { SDKConfig, EventOptions, UserProfile } from "./types";
+export declare class WebSDK {
+    private readonly apiKey;
+    private readonly endpoint;
+    private readonly debug;
+    private readonly maxBatchSize;
+    private readonly batchInterval;
+    private readonly sdkVersion;
+    private deviceId;
+    private deviceDetails?;
+    private currentUser?;
+    private eventQueue;
+    private isProcessingQueue;
+    private customAttributes;
+    constructor(config: SDKConfig);
+    identify(userId: string, traits?: Record<string, any>): void;
+    trackEvent(eventName: string, properties?: Record<string, any>, options?: EventOptions): void;
+    trackCustomAttribute(attributeName: string, attributeValue: any): void;
+    getUserProfile(): UserProfile | undefined;
+    private initialize;
+    private getStoredDeviceId;
+    private storeDeviceId;
+    private getGuestUserId;
+    private initializeDeviceDetails;
+    private detectDeviceType;
+    private detectBrowserType;
+    private detectBrowserVersion;
+    private startBatchProcessing;
+    private queueEvent;
+    private processBatch;
+    private sendBatchToServer;
+}

package/dist/web-sdk.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSDK = void 0;
+const utils_1 = require("./utils");
+const uuid_1 = require("uuid");
+const STORAGE_PREFIX = "os.";
+const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_BATCH_INTERVAL = 10000;
+const SDK_VERSION = "1.0.6";
+class WebSDK {
+    constructor(config) {
+        var _a;
+        this.maxBatchSize = DEFAULT_BATCH_SIZE;
+        this.batchInterval = DEFAULT_BATCH_INTERVAL;
+        this.sdkVersion = SDK_VERSION;
+        this.eventQueue = [];
+        this.isProcessingQueue = false;
+        this.customAttributes = {};
+        this.apiKey = config.apiKey;
+        this.endpoint = config.endpoint;
+        this.debug = (_a = config.debug) !== null && _a !== void 0 ? _a : false;
+        this.deviceId = this.getStoredDeviceId() || (0, uuid_1.v4)();
+        this.initialize();
+    }
+    identify(userId, traits = {}) {
+        var _a;
+        this.currentUser = {
+            id: userId || this.getGuestUserId(),
+            user_type: userId ? "registered" : "guest",
+            traits: { ...(_a = this.currentUser) === null || _a === void 0 ? void 0 : _a.traits, ...traits },
+        };
+        this.trackEvent("user_identified", {
+            user_id: this.currentUser.id,
+            traits,
+        });
+    }
+    trackEvent(eventName, properties = {}, options = {}) {
+        const payload = {
+            deviceId: this.deviceId,
+            eventName,
+            timestamp: options.timestamp || Date.now(),
+            requestId: options.requestId || (0, uuid_1.v4)(),
+            properties,
+        };
+        this.queueEvent(payload);
+    }
+    trackCustomAttribute(attributeName, attributeValue) {
+        this.customAttributes[attributeName] = attributeValue;
+    }
+    getUserProfile() {
+        return this.currentUser;
+    }
+    initialize() {
+        this.storeDeviceId();
+        this.initializeDeviceDetails();
+        this.identify("");
+        this.startBatchProcessing();
+        (0, utils_1.log)(this.debug, "SDK Initialized");
+    }
+    getStoredDeviceId() {
+        return localStorage.getItem(`${STORAGE_PREFIX}${this.apiKey}.device_id`);
+    }
+    storeDeviceId() {
+        localStorage.setItem(`${STORAGE_PREFIX}${this.apiKey}.device_id`, this.deviceId);
+    }
+    getGuestUserId() {
+        return `guest_user_${this.deviceId}`;
+    }
+    async initializeDeviceDetails() {
+        this.deviceDetails = {
+            deviceModel: await this.detectDeviceType(),
+            browser: this.detectBrowserType(),
+            browserVersion: this.detectBrowserVersion(),
+        };
+    }
+    async detectDeviceType() {
+        if ("userAgentData" in navigator) {
+            try {
+                const data = await navigator.userAgentData.getHighEntropyValues(["platform", "mobile"]);
+                if (data.mobile) {
+                    return data.platform.toLowerCase().includes("ios")
+                        ? "ios"
+                        : "android";
+                }
+                const platform = data.platform.toLowerCase();
+                if (platform.includes("mac"))
+                    return "mac";
+                if (platform.includes("win"))
+                    return "windows";
+                if (platform.includes("linux"))
+                    return "linux";
+            }
+            catch (error) {
+                (0, utils_1.log)(this.debug, "Client Hints API failed", error);
+            }
+        }
+        const userAgent = navigator.userAgent.toLowerCase();
+        if (/iphone|ipad|ipod/.test(userAgent))
+            return "ios";
+        if (/android/.test(userAgent))
+            return "android";
+        if (/macintosh|mac os x/.test(userAgent))
+            return "mac";
+        if (/windows|win32|win64/.test(userAgent))
+            return "windows";
+        if (/linux/.test(userAgent))
+            return "linux";
+        return "unknown";
+    }
+    detectBrowserType() {
+        if ("userAgentData" in navigator) {
+            try {
+                const brands = navigator.userAgentData.brands;
+                const brand = brands.find((b) => !["Chrome HTML", "Chromium", "Not A(Brand"].includes(b.brand));
+                if (brand)
+                    return brand.brand.toLowerCase();
+            }
+            catch (error) {
+                (0, utils_1.log)(this.debug, "Browser detection failed", error);
+            }
+        }
+        const userAgent = navigator.userAgent.toLowerCase();
+        if (/edg\//.test(userAgent))
+            return "edge";
+        if (/chrome/.test(userAgent) && !/edg\//.test(userAgent))
+            return "chrome";
+        if (/firefox/.test(userAgent))
+            return "firefox";
+        if (/safari/.test(userAgent) && !/chrome/.test(userAgent))
+            return "safari";
+        return "unknown";
+    }
+    detectBrowserVersion() {
+        if ("userAgentData" in navigator) {
+            try {
+                const brands = navigator.userAgentData.brands;
+                const brand = brands.find((b) => !["Chrome HTML", "Chromium", "Not A(Brand"].includes(b.brand));
+                if (brand)
+                    return brand.version;
+            }
+            catch (error) {
+                (0, utils_1.log)(this.debug, "Browser version detection failed", error);
+            }
+        }
+        const userAgent = navigator.userAgent.toLowerCase();
+        const browserPatterns = {
+            chrome: /chrome\/(\d+)/,
+            firefox: /firefox\/(\d+)/,
+            safari: /version\/(\d+)/,
+            edge: /edg\/(\d+)/,
+        };
+        const browserType = this.detectBrowserType();
+        const pattern = browserPatterns[browserType];
+        if (!pattern)
+            return "unknown";
+        const match = userAgent.match(pattern);
+        return match ? match[1] : "unknown";
+    }
+    startBatchProcessing() {
+        setInterval(() => {
+            if (this.eventQueue.length > 0) {
+                this.processBatch();
+            }
+        }, this.batchInterval);
+    }
+    queueEvent(payload) {
+        this.eventQueue.push(payload);
+        (0, utils_1.log)(this.debug, "Event queued", payload);
+        if (this.eventQueue.length >= this.maxBatchSize) {
+            this.processBatch();
+        }
+    }
+    async processBatch() {
+        if (this.isProcessingQueue)
+            return;
+        this.isProcessingQueue = true;
+        const batchToSend = this.eventQueue.splice(0, this.maxBatchSize);
+        try {
+            await this.sendBatchToServer(batchToSend);
+        }
+        catch (error) {
+            this.eventQueue.unshift(...batchToSend);
+            (0, utils_1.log)(this.debug, "Batch processing failed", error);
+        }
+        finally {
+            this.isProcessingQueue = false;
+        }
+    }
+    async sendBatchToServer(batch) {
+        var _a;
+        const payload = {
+            sdkVersion: this.sdkVersion,
+            deviceInfo: this.deviceDetails,
+            userId: (_a = this.currentUser) === null || _a === void 0 ? void 0 : _a.id,
+            events: batch,
+            userAttributes: this.customAttributes,
+        };
+        try {
+            const response = await fetch(`${this.endpoint}/analytics/data`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": this.apiKey,
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            await response.json();
+        }
+        catch (error) {
+            (0, utils_1.log)(this.debug, "Failed to send batch to server", error);
+            throw error;
+        }
+    }
+}
+exports.WebSDK = WebSDK;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@ordersune/crm-web-sdk",
+  "version": "1.0.6",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "uuid": "^11.0.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/uuid": "^9.0.0"
+  }
+}