npm - @callforge/tracking-client - Versions diffs - 0.0.1 - Mend

@callforge/tracking-client 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,154 @@
+# @callforge/tracking-client
+Lightweight client library for the CallForge tracking API. Handles location-aware phone number assignment with aggressive caching and preload optimization.
+## Installation
+```bash
+npm install @callforge/tracking-client
+# or
+pnpm add @callforge/tracking-client
+```
+## Quick Start
+### 1. Add preload snippet to `<head>` (optional but recommended)
+For optimal performance on static sites, add this snippet to your HTML `<head>`:
+```typescript
+import { getPreloadSnippet } from '@callforge/tracking-client';
+const snippet = getPreloadSnippet({ categoryId: 'your-category-id' });
+// Add snippet to your HTML <head>
+```
+Generated HTML:
+```html
+<link rel="preconnect" href="https://tracking.callforge.io">
+<script>/* preload script */</script>
+```
+### 2. Initialize and use the client
+```typescript
+import { CallForge } from '@callforge/tracking-client';
+const client = CallForge.init({
+  categoryId: 'your-category-id',
+  // endpoint: 'https://tracking-dev.callforge.io', // Optional: override for dev
+});
+// Promise style
+const session = await client.getSession();
+console.log(session.phoneNumber);  // "+17705550000" or null
+console.log(session.location);     // { city: "Woodstock", state: "Georgia", stateCode: "GA" } or null
+// Subscription style
+client.onReady((session) => {
+  document.getElementById('phone').textContent = session.phoneNumber;
+  document.getElementById('city').textContent = session.location?.city;
+});
+```
+## API Reference
+### `CallForge.init(config)`
+Initialize the tracking client.
+```typescript
+interface CallForgeConfig {
+  categoryId: string;    // Required - which number pool to use
+  endpoint?: string;     // Optional - defaults to 'https://tracking.callforge.io'
+}
+```
+### `client.getSession()`
+Get tracking session data. Returns cached data if valid, otherwise fetches from API.
+```typescript
+interface TrackingSession {
+  sessionId: string | null;
+  phoneNumber: string | null;
+  location: {
+    city: string;
+    state: string;      // Full name: "Georgia"
+    stateCode: string;  // Abbreviation: "GA"
+  } | null;
+}
+```
+**Behavior:**
+- Returns `null` values immediately if no `loc_physical_ms` in URL (no API call)
+- Returns cached data if valid (same location, not expired)
+- Fetches fresh data if cache expired or location changed
+- Throws on network errors or API errors
+### `client.onReady(callback)`
+Subscribe to session ready event. Callback is called once session data is available.
+```typescript
+client.onReady((session) => {
+  // session is the same TrackingSession object
+});
+```
+### `getPreloadSnippet(config)`
+Generate HTML snippet for preloading tracking data.
+```typescript
+import { getPreloadSnippet } from '@callforge/tracking-client';
+const html = getPreloadSnippet({
+  categoryId: 'your-category-id',
+  endpoint: 'https://tracking.callforge.io', // Optional
+});
+```
+## Caching Behavior
+- **Cache key:** `loc_physical_ms` parameter from URL
+- **TTL:** 30 minutes (controlled by server)
+- **Storage:** localStorage (falls back to memory if unavailable)
+- **Invalidation:** Cache clears when location changes
+## Error Handling
+```typescript
+try {
+  const session = await client.getSession();
+  if (session.phoneNumber) {
+    // Use phone number
+  } else {
+    // No phone number available for this location
+  }
+} catch (err) {
+  // Network error or API error
+  console.error('Failed to get tracking session:', err);
+}
+```
+## TypeScript
+Full type definitions are included:
+```typescript
+import type {
+  CallForgeConfig,
+  TrackingSession,
+  TrackingLocation,
+  ReadyCallback,
+} from '@callforge/tracking-client';
+```
+## Environment URLs
+| Environment | Endpoint |
+|-------------|----------|
+| Production | `https://tracking.callforge.io` (default) |
+| Staging | `https://tracking-staging.callforge.io` |
+| Dev | `https://tracking-dev.callforge.io` |

package/dist/index.d.mts ADDED Viewed

@@ -0,0 +1,102 @@
+/**
+ * Configuration options for the CallForge tracking client.
+ */
+interface CallForgeConfig {
+    /** Required - which number pool to use */
+    categoryId: string;
+    /** Optional - API endpoint. Defaults to 'https://tracking.callforge.io' */
+    endpoint?: string;
+}
+/**
+ * Location data returned by the tracking API.
+ */
+interface TrackingLocation {
+    /** City name */
+    city: string;
+    /** Full state name (e.g., "Georgia") */
+    state: string;
+    /** State abbreviation (e.g., "GA") */
+    stateCode: string;
+}
+/**
+ * Session data returned by getSession().
+ */
+interface TrackingSession {
+    /** Session ID from the tracking API */
+    sessionId: string | null;
+    /** Assigned phone number, or null if no number available */
+    phoneNumber: string | null;
+    /** Location data, or null if location could not be resolved */
+    location: TrackingLocation | null;
+}
+/**
+ * Internal API response format (includes expiresAt).
+ */
+interface ApiResponse {
+    sessionId: string;
+    phoneNumber: string | null;
+    location: {
+        city: string;
+        state: string;
+        stateCode: string;
+    } | null;
+    expiresAt: number;
+}
+/**
+ * Callback function for onReady subscription.
+ */
+type ReadyCallback = (session: TrackingSession) => void;
+/**
+ * Global window extension for preload promise.
+ */
+declare global {
+    interface Window {
+        __cfTracking?: Promise<ApiResponse>;
+    }
+}
+declare class CallForge {
+    private readonly config;
+    private readonly cache;
+    private sessionPromise;
+    private constructor();
+    /**
+     * Initialize the CallForge tracking client.
+     */
+    static init(config: CallForgeConfig): CallForge;
+    /**
+     * Get tracking session data.
+     * Returns cached data if valid, otherwise fetches from API.
+     */
+    getSession(): Promise<TrackingSession>;
+    /**
+     * Subscribe to session ready event.
+     * Callback is called once session data is available.
+     */
+    onReady(callback: ReadyCallback): void;
+    private fetchSession;
+    private getLocationId;
+    private fetchFromApi;
+    private saveToCache;
+    private formatSession;
+    private formatApiResponse;
+}
+/**
+ * Generate HTML snippet for preloading tracking data.
+ * Add this to the <head> of your HTML for optimal performance.
+ *
+ * The generated snippet:
+ * - Checks for loc_physical_ms URL parameter
+ * - Checks localStorage cache for valid session
+ * - If cache valid, resolves Promise.resolve(cached) immediately
+ * - If cache expired but same location, includes sessionId for refresh
+ * - Otherwise fetches fresh session data
+ * - Sets window.__cfTracking with the session promise
+ *
+ * @throws {Error} If categoryId contains invalid characters
+ * @throws {Error} If endpoint is not a valid HTTPS URL
+ */
+declare function getPreloadSnippet(config: CallForgeConfig): string;
+export { CallForge, type CallForgeConfig, type ReadyCallback, type TrackingLocation, type TrackingSession, getPreloadSnippet };

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,102 @@
+/**
+ * Configuration options for the CallForge tracking client.
+ */
+interface CallForgeConfig {
+    /** Required - which number pool to use */
+    categoryId: string;
+    /** Optional - API endpoint. Defaults to 'https://tracking.callforge.io' */
+    endpoint?: string;
+}
+/**
+ * Location data returned by the tracking API.
+ */
+interface TrackingLocation {
+    /** City name */
+    city: string;
+    /** Full state name (e.g., "Georgia") */
+    state: string;
+    /** State abbreviation (e.g., "GA") */
+    stateCode: string;
+}
+/**
+ * Session data returned by getSession().
+ */
+interface TrackingSession {
+    /** Session ID from the tracking API */
+    sessionId: string | null;
+    /** Assigned phone number, or null if no number available */
+    phoneNumber: string | null;
+    /** Location data, or null if location could not be resolved */
+    location: TrackingLocation | null;
+}
+/**
+ * Internal API response format (includes expiresAt).
+ */
+interface ApiResponse {
+    sessionId: string;
+    phoneNumber: string | null;
+    location: {
+        city: string;
+        state: string;
+        stateCode: string;
+    } | null;
+    expiresAt: number;
+}
+/**
+ * Callback function for onReady subscription.
+ */
+type ReadyCallback = (session: TrackingSession) => void;
+/**
+ * Global window extension for preload promise.
+ */
+declare global {
+    interface Window {
+        __cfTracking?: Promise<ApiResponse>;
+    }
+}
+declare class CallForge {
+    private readonly config;
+    private readonly cache;
+    private sessionPromise;
+    private constructor();
+    /**
+     * Initialize the CallForge tracking client.
+     */
+    static init(config: CallForgeConfig): CallForge;
+    /**
+     * Get tracking session data.
+     * Returns cached data if valid, otherwise fetches from API.
+     */
+    getSession(): Promise<TrackingSession>;
+    /**
+     * Subscribe to session ready event.
+     * Callback is called once session data is available.
+     */
+    onReady(callback: ReadyCallback): void;
+    private fetchSession;
+    private getLocationId;
+    private fetchFromApi;
+    private saveToCache;
+    private formatSession;
+    private formatApiResponse;
+}
+/**
+ * Generate HTML snippet for preloading tracking data.
+ * Add this to the <head> of your HTML for optimal performance.
+ *
+ * The generated snippet:
+ * - Checks for loc_physical_ms URL parameter
+ * - Checks localStorage cache for valid session
+ * - If cache valid, resolves Promise.resolve(cached) immediately
+ * - If cache expired but same location, includes sessionId for refresh
+ * - Otherwise fetches fresh session data
+ * - Sets window.__cfTracking with the session promise
+ *
+ * @throws {Error} If categoryId contains invalid characters
+ * @throws {Error} If endpoint is not a valid HTTPS URL
+ */
+declare function getPreloadSnippet(config: CallForgeConfig): string;
+export { CallForge, type CallForgeConfig, type ReadyCallback, type TrackingLocation, type TrackingSession, getPreloadSnippet };

package/dist/index.js ADDED Viewed

@@ -0,0 +1,256 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CallForge: () => CallForge,
+  getPreloadSnippet: () => getPreloadSnippet
+});
+module.exports = __toCommonJS(index_exports);
+// src/cache.ts
+var EXPIRY_BUFFER_MS = 3e4;
+var TrackingCache = class {
+  constructor(categoryId) {
+    this.memoryCache = null;
+    this.useMemory = false;
+    this.key = `cf_tracking_${categoryId}`;
+    this.useMemory = !this.isLocalStorageAvailable();
+  }
+  isLocalStorageAvailable() {
+    try {
+      localStorage.setItem("__cf_test__", "1");
+      localStorage.removeItem("__cf_test__");
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Get cached session if valid (same locationId and not expired).
+   * Returns null if cache miss, location changed, or expired.
+   */
+  get(locationId) {
+    const cached = this.read();
+    if (!cached) return null;
+    if (cached.locId !== locationId) return null;
+    if (cached.expiresAt - EXPIRY_BUFFER_MS <= Date.now()) return null;
+    return cached;
+  }
+  /**
+   * Get sessionId for refresh if location matches (regardless of expiry).
+   * Used when cache is expired but location is same - send sessionId to server.
+   */
+  getSessionId(locationId) {
+    const cached = this.read();
+    if (!cached) return null;
+    if (cached.locId !== locationId) return null;
+    return cached.sessionId;
+  }
+  /**
+   * Store session data in cache.
+   */
+  set(session) {
+    if (this.useMemory) {
+      this.memoryCache = session;
+    } else {
+      try {
+        localStorage.setItem(this.key, JSON.stringify(session));
+      } catch (e) {
+        this.memoryCache = session;
+      }
+    }
+  }
+  /**
+   * Clear cached data.
+   */
+  clear() {
+    this.memoryCache = null;
+    if (!this.useMemory) {
+      try {
+        localStorage.removeItem(this.key);
+      } catch (e) {
+      }
+    }
+  }
+  read() {
+    if (this.useMemory) {
+      return this.memoryCache;
+    }
+    try {
+      const raw = localStorage.getItem(this.key);
+      if (!raw) return null;
+      return JSON.parse(raw);
+    } catch (e) {
+      return this.memoryCache;
+    }
+  }
+};
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://tracking.callforge.io";
+var FETCH_TIMEOUT_MS = 1e4;
+var CallForge = class _CallForge {
+  constructor(config) {
+    this.sessionPromise = null;
+    this.config = {
+      categoryId: config.categoryId,
+      endpoint: config.endpoint || DEFAULT_ENDPOINT
+    };
+    this.cache = new TrackingCache(config.categoryId);
+  }
+  /**
+   * Initialize the CallForge tracking client.
+   */
+  static init(config) {
+    return new _CallForge(config);
+  }
+  /**
+   * Get tracking session data.
+   * Returns cached data if valid, otherwise fetches from API.
+   */
+  async getSession() {
+    if (this.sessionPromise) {
+      return this.sessionPromise;
+    }
+    this.sessionPromise = this.fetchSession();
+    return this.sessionPromise;
+  }
+  /**
+   * Subscribe to session ready event.
+   * Callback is called once session data is available.
+   */
+  onReady(callback) {
+    this.getSession().then(callback).catch(() => {
+    });
+  }
+  async fetchSession() {
+    const locationId = this.getLocationId();
+    if (!locationId) {
+      return { sessionId: null, phoneNumber: null, location: null };
+    }
+    const cached = this.cache.get(locationId);
+    if (cached) {
+      return this.formatSession(cached);
+    }
+    if (typeof window !== "undefined" && window.__cfTracking) {
+      try {
+        const data2 = await window.__cfTracking;
+        this.saveToCache(locationId, data2);
+        return this.formatApiResponse(data2);
+      } catch (e) {
+      }
+    }
+    const sessionId = this.cache.getSessionId(locationId);
+    const data = await this.fetchFromApi(locationId, sessionId);
+    this.saveToCache(locationId, data);
+    return this.formatApiResponse(data);
+  }
+  getLocationId() {
+    if (typeof window === "undefined") return null;
+    const params = new URLSearchParams(window.location.search);
+    return params.get("loc_physical_ms");
+  }
+  async fetchFromApi(locationId, sessionId) {
+    const { categoryId, endpoint } = this.config;
+    let url = `${endpoint}/v1/tracking/session?categoryId=${categoryId}&loc_physical_ms=${locationId}`;
+    if (sessionId) {
+      url += `&sessionId=${sessionId}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const response = await fetch(url, {
+        credentials: "omit",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`API error: ${response.status} ${response.statusText}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  saveToCache(locationId, data) {
+    const cached = {
+      locId: locationId,
+      sessionId: data.sessionId,
+      phoneNumber: data.phoneNumber,
+      location: data.location,
+      expiresAt: data.expiresAt
+    };
+    this.cache.set(cached);
+  }
+  formatSession(cached) {
+    return {
+      sessionId: cached.sessionId,
+      phoneNumber: cached.phoneNumber,
+      location: cached.location
+    };
+  }
+  formatApiResponse(data) {
+    return {
+      sessionId: data.sessionId,
+      phoneNumber: data.phoneNumber,
+      location: data.location
+    };
+  }
+};
+// src/preload.ts
+var DEFAULT_ENDPOINT2 = "https://tracking.callforge.io";
+var CATEGORY_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var HTTPS_URL_PATTERN = /^https:\/\/[a-zA-Z0-9][a-zA-Z0-9.-]*\.[a-zA-Z]{2,}$/;
+function getPreloadSnippet(config) {
+  const endpoint = config.endpoint || DEFAULT_ENDPOINT2;
+  const { categoryId } = config;
+  if (!CATEGORY_ID_PATTERN.test(categoryId)) {
+    throw new Error(
+      `Invalid categoryId: "${categoryId}". Must match pattern ${CATEGORY_ID_PATTERN}`
+    );
+  }
+  if (!HTTPS_URL_PATTERN.test(endpoint)) {
+    throw new Error(
+      `Invalid endpoint: "${endpoint}". Must be a valid HTTPS URL`
+    );
+  }
+  const cacheKey = `cf_tracking_${categoryId}`;
+  const script = `(function(){
+var loc=new URLSearchParams(location.search).get('loc_physical_ms');
+if(!loc)return;
+var key='${cacheKey}';
+try{
+var c=JSON.parse(localStorage.getItem(key));
+if(c&&c.locId===loc&&c.expiresAt>Date.now()+30000){window.__cfTracking=Promise.resolve(c);return}
+var sid=(c&&c.locId===loc)?c.sessionId:null;
+}catch(e){}
+var url='${endpoint}/v1/tracking/session?categoryId=${categoryId}&loc_physical_ms='+loc;
+if(sid)url+='&sessionId='+sid;
+window.__cfTracking=fetch(url,{credentials:'omit'}).then(function(r){return r.json()});
+})();`.replace(/\n/g, "");
+  return `<link rel="preconnect" href="${endpoint}">
+<script>${script}</script>`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CallForge,
+  getPreloadSnippet
+});

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,228 @@
+// src/cache.ts
+var EXPIRY_BUFFER_MS = 3e4;
+var TrackingCache = class {
+  constructor(categoryId) {
+    this.memoryCache = null;
+    this.useMemory = false;
+    this.key = `cf_tracking_${categoryId}`;
+    this.useMemory = !this.isLocalStorageAvailable();
+  }
+  isLocalStorageAvailable() {
+    try {
+      localStorage.setItem("__cf_test__", "1");
+      localStorage.removeItem("__cf_test__");
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  /**
+   * Get cached session if valid (same locationId and not expired).
+   * Returns null if cache miss, location changed, or expired.
+   */
+  get(locationId) {
+    const cached = this.read();
+    if (!cached) return null;
+    if (cached.locId !== locationId) return null;
+    if (cached.expiresAt - EXPIRY_BUFFER_MS <= Date.now()) return null;
+    return cached;
+  }
+  /**
+   * Get sessionId for refresh if location matches (regardless of expiry).
+   * Used when cache is expired but location is same - send sessionId to server.
+   */
+  getSessionId(locationId) {
+    const cached = this.read();
+    if (!cached) return null;
+    if (cached.locId !== locationId) return null;
+    return cached.sessionId;
+  }
+  /**
+   * Store session data in cache.
+   */
+  set(session) {
+    if (this.useMemory) {
+      this.memoryCache = session;
+    } else {
+      try {
+        localStorage.setItem(this.key, JSON.stringify(session));
+      } catch (e) {
+        this.memoryCache = session;
+      }
+    }
+  }
+  /**
+   * Clear cached data.
+   */
+  clear() {
+    this.memoryCache = null;
+    if (!this.useMemory) {
+      try {
+        localStorage.removeItem(this.key);
+      } catch (e) {
+      }
+    }
+  }
+  read() {
+    if (this.useMemory) {
+      return this.memoryCache;
+    }
+    try {
+      const raw = localStorage.getItem(this.key);
+      if (!raw) return null;
+      return JSON.parse(raw);
+    } catch (e) {
+      return this.memoryCache;
+    }
+  }
+};
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://tracking.callforge.io";
+var FETCH_TIMEOUT_MS = 1e4;
+var CallForge = class _CallForge {
+  constructor(config) {
+    this.sessionPromise = null;
+    this.config = {
+      categoryId: config.categoryId,
+      endpoint: config.endpoint || DEFAULT_ENDPOINT
+    };
+    this.cache = new TrackingCache(config.categoryId);
+  }
+  /**
+   * Initialize the CallForge tracking client.
+   */
+  static init(config) {
+    return new _CallForge(config);
+  }
+  /**
+   * Get tracking session data.
+   * Returns cached data if valid, otherwise fetches from API.
+   */
+  async getSession() {
+    if (this.sessionPromise) {
+      return this.sessionPromise;
+    }
+    this.sessionPromise = this.fetchSession();
+    return this.sessionPromise;
+  }
+  /**
+   * Subscribe to session ready event.
+   * Callback is called once session data is available.
+   */
+  onReady(callback) {
+    this.getSession().then(callback).catch(() => {
+    });
+  }
+  async fetchSession() {
+    const locationId = this.getLocationId();
+    if (!locationId) {
+      return { sessionId: null, phoneNumber: null, location: null };
+    }
+    const cached = this.cache.get(locationId);
+    if (cached) {
+      return this.formatSession(cached);
+    }
+    if (typeof window !== "undefined" && window.__cfTracking) {
+      try {
+        const data2 = await window.__cfTracking;
+        this.saveToCache(locationId, data2);
+        return this.formatApiResponse(data2);
+      } catch (e) {
+      }
+    }
+    const sessionId = this.cache.getSessionId(locationId);
+    const data = await this.fetchFromApi(locationId, sessionId);
+    this.saveToCache(locationId, data);
+    return this.formatApiResponse(data);
+  }
+  getLocationId() {
+    if (typeof window === "undefined") return null;
+    const params = new URLSearchParams(window.location.search);
+    return params.get("loc_physical_ms");
+  }
+  async fetchFromApi(locationId, sessionId) {
+    const { categoryId, endpoint } = this.config;
+    let url = `${endpoint}/v1/tracking/session?categoryId=${categoryId}&loc_physical_ms=${locationId}`;
+    if (sessionId) {
+      url += `&sessionId=${sessionId}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const response = await fetch(url, {
+        credentials: "omit",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`API error: ${response.status} ${response.statusText}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  saveToCache(locationId, data) {
+    const cached = {
+      locId: locationId,
+      sessionId: data.sessionId,
+      phoneNumber: data.phoneNumber,
+      location: data.location,
+      expiresAt: data.expiresAt
+    };
+    this.cache.set(cached);
+  }
+  formatSession(cached) {
+    return {
+      sessionId: cached.sessionId,
+      phoneNumber: cached.phoneNumber,
+      location: cached.location
+    };
+  }
+  formatApiResponse(data) {
+    return {
+      sessionId: data.sessionId,
+      phoneNumber: data.phoneNumber,
+      location: data.location
+    };
+  }
+};
+// src/preload.ts
+var DEFAULT_ENDPOINT2 = "https://tracking.callforge.io";
+var CATEGORY_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var HTTPS_URL_PATTERN = /^https:\/\/[a-zA-Z0-9][a-zA-Z0-9.-]*\.[a-zA-Z]{2,}$/;
+function getPreloadSnippet(config) {
+  const endpoint = config.endpoint || DEFAULT_ENDPOINT2;
+  const { categoryId } = config;
+  if (!CATEGORY_ID_PATTERN.test(categoryId)) {
+    throw new Error(
+      `Invalid categoryId: "${categoryId}". Must match pattern ${CATEGORY_ID_PATTERN}`
+    );
+  }
+  if (!HTTPS_URL_PATTERN.test(endpoint)) {
+    throw new Error(
+      `Invalid endpoint: "${endpoint}". Must be a valid HTTPS URL`
+    );
+  }
+  const cacheKey = `cf_tracking_${categoryId}`;
+  const script = `(function(){
+var loc=new URLSearchParams(location.search).get('loc_physical_ms');
+if(!loc)return;
+var key='${cacheKey}';
+try{
+var c=JSON.parse(localStorage.getItem(key));
+if(c&&c.locId===loc&&c.expiresAt>Date.now()+30000){window.__cfTracking=Promise.resolve(c);return}
+var sid=(c&&c.locId===loc)?c.sessionId:null;
+}catch(e){}
+var url='${endpoint}/v1/tracking/session?categoryId=${categoryId}&loc_physical_ms='+loc;
+if(sid)url+='&sessionId='+sid;
+window.__cfTracking=fetch(url,{credentials:'omit'}).then(function(r){return r.json()});
+})();`.replace(/\n/g, "");
+  return `<link rel="preconnect" href="${endpoint}">
+<script>${script}</script>`;
+}
+export {
+  CallForge,
+  getPreloadSnippet
+};

package/package.json ADDED Viewed

@@ -0,0 +1,30 @@
+{
+  "name": "@callforge/tracking-client",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@callforge/tsconfig": "workspace:*",
+    "jsdom": "^27.4.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.6.0"
+  }
+}