@dashgram/javascript 1.0.0

package/dist/trackers/interaction-tracker.js

@@ -0,0 +1,145 @@
+import { BaseTracker } from './base-tracker';
+import { throttle } from '../utils/helpers';
+import { getElementSelector, getElementText } from '../utils/helpers';
+import { getCurrentPath, getPageTitle, getCurrentUrl } from '../utils/device';
+export class InteractionTracker extends BaseTracker {
+    constructor(config, trackCallback) {
+        super(config, trackCallback, 2);
+        this.unsubscribers = [];
+        this.lastPath = '';
+    }
+    setup() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        this.trackScreenView();
+        this.setupHistoryTracking();
+        this.setupClickTracking();
+        this.setupFormTracking();
+        this.setupInputTracking();
+        this.setupErrorTracking();
+    }
+    teardown() {
+        this.unsubscribers.forEach((unsubscribe) => unsubscribe());
+        this.unsubscribers = [];
+    }
+    trackScreenView() {
+        const path = getCurrentPath();
+        if (path === this.lastPath) {
+            return;
+        }
+        this.lastPath = path;
+        this.track('screen_view', {
+            path,
+            url: getCurrentUrl(),
+            title: getPageTitle(),
+            referrer: document.referrer || 'direct',
+        });
+    }
+    setupHistoryTracking() {
+        const originalPushState = history.pushState;
+        const originalReplaceState = history.replaceState;
+        const trackOnHistoryChange = () => {
+            this.trackScreenView();
+        };
+        history.pushState = function (...args) {
+            originalPushState.apply(history, args);
+            trackOnHistoryChange();
+        };
+        history.replaceState = function (...args) {
+            originalReplaceState.apply(history, args);
+            trackOnHistoryChange();
+        };
+        window.addEventListener('popstate', trackOnHistoryChange);
+        this.unsubscribers.push(() => {
+            history.pushState = originalPushState;
+            history.replaceState = originalReplaceState;
+            window.removeEventListener('popstate', trackOnHistoryChange);
+        });
+    }
+    setupClickTracking() {
+        const handleClick = (event) => {
+            const target = event.target;
+            if (!target)
+                return;
+            const button = target.closest('button, [role="button"], a');
+            if (button) {
+                const tagName = button.tagName.toLowerCase();
+                const isLink = tagName === 'a';
+                this.track(isLink ? 'link_click' : 'button_click', {
+                    element: getElementSelector(button),
+                    text: getElementText(button),
+                    href: isLink ? button.href : undefined,
+                    target: isLink ? button.target : undefined,
+                });
+            }
+        };
+        document.addEventListener('click', handleClick, { capture: true });
+        this.unsubscribers.push(() => {
+            document.removeEventListener('click', handleClick, { capture: true });
+        });
+    }
+    setupFormTracking() {
+        const handleSubmit = (event) => {
+            const form = event.target;
+            if (!form)
+                return;
+            this.track('form_submit', {
+                form_id: form.id || undefined,
+                form_name: form.name || undefined,
+                form_action: form.action || undefined,
+                form_method: form.method || undefined,
+            });
+        };
+        document.addEventListener('submit', handleSubmit, { capture: true });
+        this.unsubscribers.push(() => {
+            document.removeEventListener('submit', handleSubmit, { capture: true });
+        });
+    }
+    setupInputTracking() {
+        const handleFocus = throttle((event) => {
+            const target = event.target;
+            if (!target)
+                return;
+            const tagName = target.tagName.toLowerCase();
+            if (['input', 'textarea', 'select'].includes(tagName)) {
+                const input = target;
+                this.track('input_focus', {
+                    element: getElementSelector(input),
+                    input_type: input.type || tagName,
+                    input_name: input.name || undefined,
+                    input_id: input.id || undefined,
+                });
+            }
+        }, 1000);
+        document.addEventListener('focus', handleFocus, { capture: true });
+        this.unsubscribers.push(() => {
+            document.removeEventListener('focus', handleFocus, { capture: true });
+        });
+    }
+    setupErrorTracking() {
+        const handleError = (event) => {
+            this.track('js_error', {
+                message: event.message,
+                filename: event.filename,
+                lineno: event.lineno,
+                colno: event.colno,
+                stack: event.error?.stack,
+            });
+        };
+        window.addEventListener('error', handleError);
+        this.unsubscribers.push(() => {
+            window.removeEventListener('error', handleError);
+        });
+        const handleRejection = (event) => {
+            this.track('unhandled_rejection', {
+                reason: String(event.reason),
+                promise: String(event.promise),
+            });
+        };
+        window.addEventListener('unhandledrejection', handleRejection);
+        this.unsubscribers.push(() => {
+            window.removeEventListener('unhandledrejection', handleRejection);
+        });
+    }
+}

package/dist/transport/batch-processor.d.ts

@@ -0,0 +1,19 @@
+import type { DashgramEvent } from '../types';
+import type { Config } from '../core/config';
+import { Transport } from './transport';
+export declare class BatchProcessor {
+    private config;
+    private queue;
+    private transport;
+    private flushTimer;
+    private isStarted;
+    constructor(config: Config, transport: Transport);
+    start(): void;
+    stop(): void;
+    addEvent(event: DashgramEvent): void;
+    private scheduleFlush;
+    flush(): void;
+    flushAsync(): Promise<void>;
+    private setupPageUnloadHandler;
+}
+//# sourceMappingURL=batch-processor.d.ts.map

package/dist/transport/batch-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processor.d.ts","sourceRoot":"","sources":["../../src/transport/batch-processor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKxC,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,SAAS,CAAkB;gBAEvB,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS;IAShD,KAAK,IAAI,IAAI;IAab,IAAI,IAAI,IAAI;IAYZ,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAapC,OAAO,CAAC,aAAa;IAkBrB,KAAK,IAAI,IAAI;IAWP,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAajC,OAAO,CAAC,sBAAsB;CAwB/B"}

package/dist/transport/batch-processor.js

@@ -0,0 +1,75 @@
+import { EventQueue } from '../core/event-queue';
+export class BatchProcessor {
+    constructor(config, transport) {
+        this.flushTimer = null;
+        this.isStarted = false;
+        this.config = config;
+        this.transport = transport;
+        this.queue = new EventQueue(200);
+    }
+    start() {
+        if (this.isStarted) {
+            return;
+        }
+        this.isStarted = true;
+        this.scheduleFlush();
+        this.setupPageUnloadHandler();
+    }
+    stop() {
+        this.isStarted = false;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    addEvent(event) {
+        this.queue.enqueue(event);
+        const batchSize = this.config.get('batchSize');
+        if (this.queue.size() >= batchSize) {
+            this.flush();
+        }
+    }
+    scheduleFlush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+        }
+        const interval = this.config.get('flushInterval');
+        this.flushTimer = setTimeout(() => {
+            this.flush();
+            if (this.isStarted) {
+                this.scheduleFlush();
+            }
+        }, interval);
+    }
+    flush() {
+        const events = this.queue.flush();
+        if (events.length > 0) {
+            this.transport.send(events);
+        }
+    }
+    async flushAsync() {
+        const events = this.queue.flush();
+        if (events.length > 0) {
+            await this.transport.send(events);
+        }
+        await this.transport.flush();
+    }
+    setupPageUnloadHandler() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const handleUnload = () => {
+            const events = this.queue.flush();
+            if (events.length > 0) {
+                this.transport.sendBeacon(events);
+            }
+        };
+        window.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                handleUnload();
+            }
+        });
+        window.addEventListener('pagehide', handleUnload);
+        window.addEventListener('beforeunload', handleUnload);
+    }
+}

package/dist/transport/transport.d.ts

@@ -0,0 +1,16 @@
+import type { DashgramEvent } from "../types";
+import type { Config } from "../core/config";
+export declare class Transport {
+    private config;
+    private isOnline;
+    private pendingRequests;
+    constructor(config: Config);
+    private setupOnlineListener;
+    send(events: DashgramEvent[]): Promise<void>;
+    private sendRequest;
+    sendBeacon(events: DashgramEvent[]): boolean;
+    flush(): Promise<void>;
+    private log;
+    private logError;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/transport/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAO5C,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,eAAe,CAAgC;gBAE3C,MAAM,EAAE,MAAM;IAQ1B,OAAO,CAAC,mBAAmB;IAuBrB,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;YAuDpC,WAAW;IAqDzB,UAAU,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,OAAO;IAmCtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B,OAAO,CAAC,GAAG;IASX,OAAO,CAAC,QAAQ;CAKjB"}

package/dist/transport/transport.js

@@ -0,0 +1,140 @@
+import { safeStringify } from "../utils/helpers";
+import { InvalidCredentialsError, DashgramAPIError, NetworkError } from "../errors";
+export class Transport {
+    constructor(config) {
+        this.isOnline = true;
+        this.pendingRequests = new Set();
+        this.config = config;
+        this.setupOnlineListener();
+    }
+    setupOnlineListener() {
+        if (typeof window === "undefined") {
+            return;
+        }
+        window.addEventListener("online", () => {
+            this.isOnline = true;
+            this.log("Connection restored");
+        });
+        window.addEventListener("offline", () => {
+            this.isOnline = false;
+            this.log("Connection lost");
+        });
+        this.isOnline = navigator.onLine;
+    }
+    async send(events) {
+        if (events.length === 0) {
+            return;
+        }
+        if (this.config.isDisabled()) {
+            this.log("Tracking disabled, skipping send");
+            return;
+        }
+        if (!this.isOnline) {
+            this.log("Offline, skipping send");
+            return;
+        }
+        const request = this.sendRequest(events);
+        this.pendingRequests.add(request);
+        try {
+            await request;
+        }
+        catch (error) {
+            this.logError("Failed to send events:", error);
+            const onError = this.config.getOnError();
+            if (onError) {
+                try {
+                    if (error instanceof InvalidCredentialsError ||
+                        error instanceof DashgramAPIError ||
+                        error instanceof NetworkError) {
+                        onError(error);
+                    }
+                    else if (error instanceof Error) {
+                        onError(new NetworkError(error));
+                    }
+                }
+                catch (handlerError) {
+                    this.logError("Error in onError callback:", handlerError);
+                }
+            }
+        }
+        finally {
+            this.pendingRequests.delete(request);
+        }
+    }
+    async sendRequest(events) {
+        const url = this.config.get("apiUrl");
+        const apiKey = this.config.get("apiKey");
+        const projectId = this.config.get("projectId");
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-API-Key": apiKey,
+                    "X-Project-ID": projectId
+                },
+                body: safeStringify({ events }),
+                keepalive: true
+            });
+            if (response.status === 403) {
+                throw new InvalidCredentialsError();
+            }
+            if (!response.ok) {
+                let details = response.statusText;
+                try {
+                    const errorData = await response.json();
+                    details = errorData.details || errorData.message || details;
+                }
+                catch {
+                }
+                throw new DashgramAPIError(response.status, details);
+            }
+            this.log(`Sent ${events.length} events successfully`);
+        }
+        catch (error) {
+            if (error instanceof InvalidCredentialsError || error instanceof DashgramAPIError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                throw new NetworkError(error);
+            }
+            throw new NetworkError(new Error(String(error)));
+        }
+    }
+    sendBeacon(events) {
+        if (events.length === 0) {
+            return true;
+        }
+        if (this.config.isDisabled()) {
+            return true;
+        }
+        if (typeof navigator === "undefined" || !navigator.sendBeacon) {
+            return false;
+        }
+        const url = this.config.get("apiUrl");
+        const apiKey = this.config.get("apiKey");
+        const projectId = this.config.get("projectId");
+        const payload = safeStringify({
+            events,
+            apiKey,
+            projectId
+        });
+        const blob = new Blob([payload], { type: "application/json" });
+        const sent = navigator.sendBeacon(url, blob);
+        this.log(`sendBeacon ${sent ? "succeeded" : "failed"} for ${events.length} events`);
+        return sent;
+    }
+    async flush() {
+        await Promise.all(Array.from(this.pendingRequests));
+    }
+    log(...args) {
+        if (this.config.isDebug()) {
+            console.log("[Dashgram Transport]", ...args);
+        }
+    }
+    logError(...args) {
+        if (this.config.isDebug()) {
+            console.error("[Dashgram Transport]", ...args);
+        }
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,61 @@
+import type { DashgramError } from "../errors";
+export type TrackLevel = 1 | 2 | 3;
+export type EventSource = "auto" | "manual";
+export interface DashgramConfig {
+    projectId: string;
+    apiKey: string;
+    trackLevel?: TrackLevel;
+    apiUrl?: string;
+    batchSize?: number;
+    flushInterval?: number;
+    debug?: boolean;
+    disabled?: boolean;
+    onError?: (error: DashgramError) => void;
+}
+export interface EventContext {
+    platform: string;
+    app_version: string;
+    language: string;
+    screen_width: number;
+    screen_height: number;
+    viewport_width: number;
+    viewport_height: number;
+    user_agent: string;
+    timezone: string;
+    telegram_version?: string;
+    theme?: string;
+}
+export type EventProperties = Record<string, any>;
+export interface DashgramEvent {
+    event: string;
+    properties: EventProperties;
+    timestamp: string;
+    source: EventSource;
+    level: TrackLevel;
+    session_id: string;
+    user_id: string | null;
+    context: EventContext;
+}
+export type UserTraits = Record<string, any>;
+export interface TelegramWebApp {
+    initDataUnsafe?: {
+        user?: {
+            id: number;
+            first_name?: string;
+            last_name?: string;
+            username?: string;
+            language_code?: string;
+        };
+    };
+    platform?: string;
+    version?: string;
+    themeParams?: Record<string, string>;
+    onEvent?: (event: string, callback: () => void) => void;
+    offEvent?: (event: string, callback: () => void) => void;
+}
+export interface TelegramWindow extends Window {
+    Telegram?: {
+        WebApp?: TelegramWebApp;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAK9C,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAKlC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAA;AAK3C,MAAM,WAAW,cAAc;IAE7B,SAAS,EAAE,MAAM,CAAA;IAGjB,MAAM,EAAE,MAAM,CAAA;IAGd,UAAU,CAAC,EAAE,UAAU,CAAA;IAGvB,MAAM,CAAC,EAAE,MAAM,CAAA;IAGf,SAAS,CAAC,EAAE,MAAM,CAAA;IAGlB,aAAa,CAAC,EAAE,MAAM,CAAA;IAGtB,KAAK,CAAC,EAAE,OAAO,CAAA;IAGf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAGlB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;CACzC;AAKD,MAAM,WAAW,YAAY;IAE3B,QAAQ,EAAE,MAAM,CAAA;IAGhB,WAAW,EAAE,MAAM,CAAA;IAGnB,QAAQ,EAAE,MAAM,CAAA;IAGhB,YAAY,EAAE,MAAM,CAAA;IAGpB,aAAa,EAAE,MAAM,CAAA;IAGrB,cAAc,EAAE,MAAM,CAAA;IAGtB,eAAe,EAAE,MAAM,CAAA;IAGvB,UAAU,EAAE,MAAM,CAAA;IAGlB,QAAQ,EAAE,MAAM,CAAA;IAGhB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAGzB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAKD,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAKjD,MAAM,WAAW,aAAa;IAE5B,KAAK,EAAE,MAAM,CAAA;IAGb,UAAU,EAAE,eAAe,CAAA;IAG3B,SAAS,EAAE,MAAM,CAAA;IAGjB,MAAM,EAAE,WAAW,CAAA;IAGnB,KAAK,EAAE,UAAU,CAAA;IAGjB,UAAU,EAAE,MAAM,CAAA;IAGlB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IAGtB,OAAO,EAAE,YAAY,CAAA;CACtB;AAKD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAK5C,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,EAAE;QACf,IAAI,CAAC,EAAE;YACL,EAAE,EAAE,MAAM,CAAA;YACV,UAAU,CAAC,EAAE,MAAM,CAAA;YACnB,SAAS,CAAC,EAAE,MAAM,CAAA;YAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;YACjB,aAAa,CAAC,EAAE,MAAM,CAAA;SACvB,CAAA;KACF,CAAA;IACD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;IACvD,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CACzD;AAKD,MAAM,WAAW,cAAe,SAAQ,MAAM;IAC5C,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,cAAc,CAAA;KACxB,CAAA;CACF"}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/device.d.ts

@@ -0,0 +1,11 @@
+import type { EventContext } from '../types';
+export declare function getDeviceContext(): EventContext;
+export declare function getViewportSize(): {
+    width: number;
+    height: number;
+};
+export declare function getScrollDepth(): number;
+export declare function getCurrentUrl(): string;
+export declare function getCurrentPath(): string;
+export declare function getPageTitle(): string;
+//# sourceMappingURL=device.d.ts.map

package/dist/utils/device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.d.ts","sourceRoot":"","sources":["../../src/utils/device.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAW7C,wBAAgB,gBAAgB,IAAI,YAAY,CA+B/C;AAKD,wBAAgB,eAAe,IAAI;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CASnE;AAKD,wBAAgB,cAAc,IAAI,MAAM,CAiBvC;AAKD,wBAAgB,aAAa,IAAI,MAAM,CAMtC;AAKD,wBAAgB,cAAc,IAAI,MAAM,CAMvC;AAKD,wBAAgB,YAAY,IAAI,MAAM,CAMrC"}

package/dist/utils/device.js

@@ -0,0 +1,72 @@
+import { getTelegramPlatform, getTelegramVersion, getTelegramLanguage, getTelegramTheme, } from './telegram';
+export function getDeviceContext() {
+    if (typeof window === 'undefined') {
+        return {
+            platform: 'unknown',
+            app_version: 'unknown',
+            language: 'unknown',
+            screen_width: 0,
+            screen_height: 0,
+            viewport_width: 0,
+            viewport_height: 0,
+            user_agent: '',
+            timezone: 'UTC',
+        };
+    }
+    const telegramLang = getTelegramLanguage();
+    const browserLang = navigator.language || 'en';
+    return {
+        platform: getTelegramPlatform(),
+        app_version: getTelegramVersion(),
+        language: telegramLang || browserLang,
+        screen_width: window.screen.width,
+        screen_height: window.screen.height,
+        viewport_width: window.innerWidth,
+        viewport_height: window.innerHeight,
+        user_agent: navigator.userAgent,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+        telegram_version: getTelegramVersion(),
+        theme: getTelegramTheme(),
+    };
+}
+export function getViewportSize() {
+    if (typeof window === 'undefined') {
+        return { width: 0, height: 0 };
+    }
+    return {
+        width: window.innerWidth,
+        height: window.innerHeight,
+    };
+}
+export function getScrollDepth() {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return 0;
+    }
+    const windowHeight = window.innerHeight;
+    const documentHeight = document.documentElement.scrollHeight;
+    const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+    if (documentHeight <= windowHeight) {
+        return 100;
+    }
+    const maxScroll = documentHeight - windowHeight;
+    const scrollPercentage = (scrollTop / maxScroll) * 100;
+    return Math.min(Math.round(scrollPercentage), 100);
+}
+export function getCurrentUrl() {
+    if (typeof window === 'undefined') {
+        return '';
+    }
+    return window.location.href;
+}
+export function getCurrentPath() {
+    if (typeof window === 'undefined') {
+        return '';
+    }
+    return window.location.pathname;
+}
+export function getPageTitle() {
+    if (typeof document === 'undefined') {
+        return '';
+    }
+    return document.title || '';
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,9 @@
+export declare function generateUUID(): string;
+export declare function getTimestamp(): string;
+export declare function throttle<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+export declare function safeStringify(obj: any): string;
+export declare function isBrowser(): boolean;
+export declare function getElementSelector(element: Element): string;
+export declare function getElementText(element: Element, maxLength?: number): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/utils/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/utils/helpers.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,IAAI,MAAM,CAWrC;AAKD,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAKD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAuBlC;AAKD,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,MAAM,GACX,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAWlC;AAKD,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAM9C;AAKD,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAKD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAa3D;AAKD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,SAAK,GAAG,MAAM,CAGvE"}

package/dist/utils/helpers.js

@@ -0,0 +1,74 @@
+export function generateUUID() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+export function getTimestamp() {
+    return new Date().toISOString();
+}
+export function throttle(func, wait) {
+    let timeout = null;
+    let previous = 0;
+    return function (...args) {
+        const now = Date.now();
+        const remaining = wait - (now - previous);
+        if (remaining <= 0 || remaining > wait) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+            previous = now;
+            func.apply(this, args);
+        }
+        else if (!timeout) {
+            timeout = setTimeout(() => {
+                previous = Date.now();
+                timeout = null;
+                func.apply(this, args);
+            }, remaining);
+        }
+    };
+}
+export function debounce(func, wait) {
+    let timeout = null;
+    return function (...args) {
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => {
+            func.apply(this, args);
+        }, wait);
+    };
+}
+export function safeStringify(obj) {
+    try {
+        return JSON.stringify(obj);
+    }
+    catch (error) {
+        return '{}';
+    }
+}
+export function isBrowser() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+export function getElementSelector(element) {
+    if (element.id) {
+        return `#${element.id}`;
+    }
+    if (element.className && typeof element.className === 'string') {
+        const classes = element.className.trim().split(/\s+/).slice(0, 2).join('.');
+        if (classes) {
+            return `${element.tagName.toLowerCase()}.${classes}`;
+        }
+    }
+    return element.tagName.toLowerCase();
+}
+export function getElementText(element, maxLength = 50) {
+    const text = element.textContent?.trim() || '';
+    return text.length > maxLength ? text.substring(0, maxLength) + '...' : text;
+}

package/dist/utils/telegram.d.ts

@@ -0,0 +1,10 @@
+import type { TelegramWebApp } from '../types';
+export declare function getTelegramWebApp(): TelegramWebApp | null;
+export declare function isTelegramMiniApp(): boolean;
+export declare function getTelegramUserId(): string | null;
+export declare function getTelegramPlatform(): string;
+export declare function getTelegramVersion(): string;
+export declare function getTelegramLanguage(): string | null;
+export declare function getTelegramTheme(): string;
+export declare function subscribeToTelegramEvent(event: string, callback: () => void): () => void;
+//# sourceMappingURL=telegram.d.ts.map

package/dist/utils/telegram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram.d.ts","sourceRoot":"","sources":["../../src/utils/telegram.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,UAAU,CAAC;AAK/D,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,IAAI,CAOzD;AAKD,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAKD,wBAAgB,iBAAiB,IAAI,MAAM,GAAG,IAAI,CAIjD;AAKD,wBAAgB,mBAAmB,IAAI,MAAM,CAG5C;AAKD,wBAAgB,kBAAkB,IAAI,MAAM,CAG3C;AAKD,wBAAgB,mBAAmB,IAAI,MAAM,GAAG,IAAI,CAGnD;AAKD,wBAAgB,gBAAgB,IAAI,MAAM,CAmBzC;AAKD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,IAAI,GACnB,MAAM,IAAI,CAgBZ"}