@gem-sdk/clarity-js 0.8.94

package/test/hash.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "@playwright/test";
+import hash from "@src/core/hash";
+
+test.describe("Core Utilities - Hash", () => {
+    test("hash function should generate consistent hash for same input", () => {
+        const input = "test-string";
+        const hash1 = hash(input);
+        const hash2 = hash(input);
+
+        expect(hash1).toBe(hash2);
+        expect(hash1).toBeTruthy();
+        expect(typeof hash1).toBe("string");
+    });
+
+    test("hash function should generate different hashes for different inputs", () => {
+        const hash1 = hash("input1");
+        const hash2 = hash("input2");
+        const hash3 = hash("completely-different-input");
+
+        expect(hash1).not.toBe(hash2);
+        expect(hash2).not.toBe(hash3);
+        expect(hash1).not.toBe(hash3);
+    });
+
+    test("hash function should respect precision parameter", () => {
+        const input = "test-precision";
+        const hashNoPrecision = hash(input);
+        const hash16 = hash(input, 16);
+        const hash8 = hash(input, 8);
+
+        expect(hashNoPrecision).toBeTruthy();
+        expect(hash16).toBeTruthy();
+        expect(hash8).toBeTruthy();
+
+        // Hash with precision should be different from no precision
+        expect(hashNoPrecision).not.toBe(hash16);
+
+        // Verify precision limits: 2^16 = 65536, 2^8 = 256
+        const hash16Num = parseInt(hash16, 36);
+        const hash8Num = parseInt(hash8, 36);
+        expect(hash16Num).toBeLessThan(65536);
+        expect(hash8Num).toBeLessThan(256);
+    });
+
+    test("hash function should handle empty strings", () => {
+        const result = hash("");
+        expect(result).toBeTruthy();
+        expect(typeof result).toBe("string");
+    });
+
+    test("hash function should handle special characters", () => {
+        const hash1 = hash("test@example.com");
+        const hash2 = hash("test#$%^&*()");
+        const hash3 = hash("🎉🎊✨");
+
+        expect(hash1).toBeTruthy();
+        expect(hash2).toBeTruthy();
+        expect(hash3).toBeTruthy();
+        expect(hash1).not.toBe(hash2);
+        expect(hash2).not.toBe(hash3);
+    });
+
+    test("hash function should produce base36 output", () => {
+        const result = hash("test-base36");
+        // Base36 should only contain 0-9 and a-z
+        expect(/^[0-9a-z]+$/.test(result)).toBe(true);
+    });
+});

package/test/time.test.ts

@@ -0,0 +1,42 @@
+import { expect, test } from "@playwright/test";
+import { start, stop, time } from "@src/core/time";
+
+test.describe("Time Utilities", () => {
+    test("time module should start and stop", () => {
+        start();
+        const time1 = time();
+
+        expect(time1).toBeGreaterThanOrEqual(0);
+
+        stop();
+        const time2 = time();
+
+        // After stop, time should still work but use different baseline
+        expect(time2).toBeGreaterThanOrEqual(0);
+    });
+
+    test("time function should track elapsed time", async () => {
+        start();
+        const time1 = time();
+
+        // Wait a bit
+        await new Promise((resolve) => setTimeout(resolve, 50));
+
+        const time2 = time();
+
+        expect(time2).toBeGreaterThan(time1);
+        expect(time2 - time1).toBeGreaterThanOrEqual(50);
+
+        stop();
+    });
+
+    test("time function should handle null event parameter", () => {
+        start();
+        const result = time(null);
+
+        expect(result).toBeGreaterThanOrEqual(0);
+        expect(typeof result).toBe("number");
+
+        stop();
+    });
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "baseUrl": ".",
+        "paths": {
+            "@src/*": ["src/*"],
+            "@clarity-types/*": ["types/*"]
+        }
+    },
+    "include":["src/**/*.ts", "types/**/*.d.ts", "test/**/*.ts", "rollup.config.ts"],
+    "exclude": ["node_modules", "build"]
+}

package/tslint.json

@@ -0,0 +1,33 @@
+{
+  "extends": "tslint:recommended",
+  "rules": {
+    "max-line-length": [
+      true,
+      140
+    ],
+    "no-console": [
+      false
+    ],
+    "no-string-literal": false,
+    "prefer-const": false,
+    "prefer-for-of": false,
+    "object-literal-sort-keys": false,
+    "one-variable-per-declaration": false,
+    "trailing-comma": [
+      false
+    ],
+    "variable-name": false,
+    "interface-name": false,
+    "interface-over-type-literal": false,
+    "only-arrow-functions": false,
+    "typedef": [
+      true,
+      "call-signature",
+      "parameter",
+      "property-declaration",
+      "member-variable-declaration",
+      "object-destructuring",
+      "array-destructuring"
+    ]
+  }
+}

package/types/agent.d.ts

@@ -0,0 +1,39 @@
+export const enum Action {
+  AgentOnline,
+  AgentOffline,
+  AgentHidden,
+  AgentMaximized,
+  AgentMinimized,
+  AgentMessage,
+  HumanMessage,
+}
+
+export const enum AuthorType {
+  Agent = "agent",
+  Customer = "customer",
+}
+
+export const enum Visibility {
+  Maximized = "maximized",
+  Minimized = "minimized",
+  Hidden = "hidden",
+}
+
+export const enum Availability {
+  Online = "online",
+  Offline = "offline",
+}
+
+export interface VisibilityEvent {
+  visibility: Visibility;
+}
+
+export interface AvailabilityEvent {
+  availability: Availability;
+}
+
+export interface NewEvent {
+  author: {
+    type: AuthorType;
+  };
+}

package/types/core.d.ts

@@ -0,0 +1,156 @@
+import * as Data from "./data";
+
+type TaskFunction = () => Promise<void>;
+type TaskResolve = () => void;
+type UploadCallback = (data: string, type?: string) => void;
+type Region = [number /* RegionId */, string /* Query Selector */];
+type Checksum = [number /* FraudId */, string /* Query Selector */];
+
+/* Enum */
+
+export const enum Priority {
+    Normal = 0,
+    High = 1
+}
+
+export const enum Time {
+    Second = 1000,
+    Minute = 60 * 1000,
+    Hour = 60 * 60 * 1000,
+    Day = 24 * 60 * 60 * 1000
+}
+
+export const enum Task {
+    Wait = 0,
+    Run = 1,
+    Stop = 2
+}
+
+export const enum ExtractSource {
+    Javascript = 0,
+    Cookie = 1,
+    Text = 2,
+    Fragment = 3,
+    Hash = 4
+}
+
+export const enum Type {
+    Array = 1,
+    Object = 2,
+    Simple = 3
+}
+
+export type Syntax = {
+    name: string,
+    type: Type,
+    condition: string
+}
+
+export const enum Privacy {
+    None = 0,
+    Sensitive = 1,
+    Text = 2,
+    TextImage = 3,
+    Exclude = 4,
+    Snapshot = 5
+}
+
+/* Helper Interfaces */
+
+export interface Module {
+    start: () => void;
+    stop: () => void;
+}
+
+export interface Tasks {
+    [key: number]: TaskInfo;
+}
+
+export interface TaskInfo {
+    start: number;
+    calls: number;
+    yield: number;
+}
+
+export interface Timer {
+    id: string;
+    cost: Data.Metric;
+}
+
+export interface RequestIdleCallbackOptions {
+    timeout: number;
+}
+
+export interface RequestIdleCallbackDeadline {
+    didTimeout: boolean;
+    timeRemaining: (() => number);
+}
+
+export interface AsyncTask {
+    task: TaskFunction;
+    resolve: TaskResolve;
+    id: string;
+}
+
+export interface OffsetDistance {
+    x: number;
+    y: number;
+}
+
+export interface BrowserEvent {
+    event: string;
+    listener: EventListener;
+    options: {
+        capture: boolean;
+        passive: boolean;
+    };
+}
+
+export interface Report {
+    v: string; // Version
+    p: string; // Project Id
+    u: string; // User Id
+    s: string; // Session Id
+    n: number; // Page Number
+    m?: string; // Message, optional
+    e?: string; // Error Stack, optional
+}
+
+export interface Config {
+    projectId?: string;
+    delay?: number;
+    lean?: boolean;
+    lite?: boolean;
+    track?: boolean;
+    content?: boolean;
+    drop?: string[];
+    mask?: string[];
+    unmask?: string[];
+    regions?: Region[];
+    cookies?: string[];
+    fraud?: boolean;
+    checksum?: Checksum[];
+    report?: string;
+    upload?: string | UploadCallback;
+    fallback?: string;
+    upgrade?: (key: string) => void;
+    action?: (key: string) => void;
+    dob?: number;
+    delayDom?: boolean;
+    throttleDom?: boolean;
+    conversions?: boolean;
+    includeSubdomains?: boolean;
+    modules?: string[];
+    diagnostics?: boolean;
+    externalSession?: boolean;
+    userId?: string;
+    sessionId?: string;
+    mode?: "gemx" | "all";
+}
+
+export const enum Constant {
+    Zone = "Zone",
+    Symbol = "__symbol__",
+    AddEventListener = "addEventListener",
+    RemoveEventListener = "removeEventListener"
+}