sdk-sample 0.0.1

package/dist/components/trackedButton/index.d.ts

@@ -0,0 +1 @@
+export * from './tracked-button';

package/dist/components/trackedButton/tracked-button.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+interface TrackedButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    eventId?: string;
+    buttonName: string;
+    extraParams?: Record<string, any>;
+    children: React.ReactNode;
+}
+/**
+ * Encapsulated Button Component that automatically tracks clicks.
+ * Uses the `useTracker` hook to send events directly.
+ */
+export declare const TrackedButton: React.FC<TrackedButtonProps>;
+export {};

package/dist/components/trackedForm/index.d.ts

@@ -0,0 +1 @@
+export * from './tracked-form';

package/dist/components/trackedForm/tracked-form.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface TrackedFormProps extends React.FormHTMLAttributes<HTMLFormElement> {
+    formId: string;
+    children: React.ReactNode;
+    transformData?: (formData: FormData) => Record<string, any>;
+}
+/**
+ * Encapsulated Form Component that automatically tracks submission.
+ */
+export declare const TrackedForm: React.FC<TrackedFormProps>;
+export {};

package/dist/components/trackedPage/index.d.ts

@@ -0,0 +1 @@
+export * from './tracked-page';

package/dist/components/trackedPage/tracked-page.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface TrackedPageProps {
+    pageTitle?: string;
+    children: React.ReactNode;
+}
+/**
+ * Component Wrapper that automatically tracks page view on mount.
+ */
+export declare const TrackedPage: React.FC<TrackedPageProps>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { Tracker } from './sdk/tracker';
+export { EventManager } from './sdk/event-manager';
+export { QueueManager } from './sdk/queue-manager';
+export { StrategyManager } from './sdk/strategy-manager';
+export { SchemaManager } from './sdk/schema-manager';
+export type { SchemaConfig, EventDefinition } from './sdk/schema-manager';
+export { TrackerProvider, useTracker, usePageView, usePageStay, useExposure } from './sdk/react-hooks';
+export { TrackedButton } from './components/trackedButton';
+export { TrackedPage } from './components/trackedPage';
+export { TrackedForm } from './components/trackedForm';
+export * from './types';

package/dist/sdk/event-manager.d.ts

@@ -0,0 +1,11 @@
+import { BaseEvent } from '../types';
+export declare class EventManager {
+    private getBaseInfo;
+    /**
+     * Factory method to create an event with base info.
+     * @param eventName Name of the event
+     * @param params Event parameters
+     * @returns Enriched event object
+     */
+    createEvent(eventName: string, params: Record<string, unknown>): BaseEvent;
+}

package/dist/sdk/queue-manager.d.ts

@@ -0,0 +1,21 @@
+import { BaseEvent } from '../types';
+import { StrategyManager } from './strategy-manager';
+export declare class QueueManager {
+    private queue;
+    private strategyManager;
+    private batchSize;
+    private timer;
+    private interval;
+    constructor(strategyManager: StrategyManager, batchSize?: number, interval?: number);
+    /**
+     * Add an event to the queue.
+     * @param event Event to track
+     * @param immediate Whether to send immediately
+     */
+    addEvent(event: BaseEvent, immediate?: boolean): void;
+    /**
+     * Flush the current queue via XHR.
+     */
+    flush(): void;
+    flushOnUnload(): void;
+}

package/dist/sdk/react-hooks.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { Tracker } from './tracker';
+interface TrackerProviderProps {
+    config: {
+        endpoint: string;
+        autoTrack?: boolean;
+        debug?: boolean;
+    };
+    children: React.ReactNode;
+}
+export declare const TrackerProvider: React.FC<TrackerProviderProps>;
+/**
+ * Hook to access the Tracker instance.
+ * @returns Tracker instance
+ * @throws Error if used outside TrackerProvider
+ */
+export declare const useTracker: () => Tracker;
+/**
+ * Hook to automatically track page view on mount.
+ * @param pageTitle Optional page title override
+ */
+export declare const usePageView: (pageTitle?: string) => void;
+/**
+ * Hook to track how long the user stays on the page/component.
+ * Tracks 'pageStay' event on unmount with duration and scroll depth.
+ */
+export declare const usePageStay: () => void;
+/**
+ * Hook to track element exposure (visibility).
+ * Tracks 'exposure' event when element becomes hidden after being visible.
+ * @param elementId Unique ID for the element
+ * @param componentName Human-readable name
+ * @returns Ref to attach to the element
+ */
+export declare const useExposure: (elementId: string, componentName: string) => React.RefObject<HTMLDivElement>;
+export {};

package/dist/sdk/schema-manager.d.ts

@@ -0,0 +1,33 @@
+export type ParamType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+export interface ParamSchema {
+    type: ParamType;
+    required?: boolean;
+    description?: string;
+}
+export interface EventDefinition {
+    priority: 'high' | 'medium' | 'low';
+    params: Record<string, ParamSchema>;
+    description?: string;
+}
+export interface SchemaConfig {
+    version: string;
+    events: Record<string, EventDefinition>;
+}
+export declare const DEFAULT_SCHEMA: SchemaConfig;
+export declare class SchemaManager {
+    private schema;
+    constructor(initialConfig?: SchemaConfig);
+    loadConfig(config: SchemaConfig): void;
+    /**
+     * Validate event parameters against the schema.
+     * @param eventName Name of the event
+     * @param params Event parameters
+     * @returns Validation result
+     */
+    validate(eventName: string, params?: Record<string, unknown>): {
+        valid: boolean;
+        errors: string[];
+    };
+    getEventPriority(eventName: string): 'high' | 'medium' | 'low';
+    private getType;
+}

package/dist/sdk/strategy-manager.d.ts

@@ -0,0 +1,14 @@
+import { ReportStrategy } from '../types';
+export declare class StrategyManager {
+    private endpoint;
+    constructor(endpoint: string);
+    /**
+     * Send data using the specified strategy.
+     * @param data Data to send
+     * @param strategy Reporting strategy (xhr, beacon, img)
+     */
+    send(data: unknown, strategy?: ReportStrategy): void;
+    private sendBeacon;
+    private sendXHR;
+    private sendImg;
+}

package/dist/sdk/tracker.d.ts

@@ -0,0 +1,41 @@
+import { EventMap } from '../types';
+import { SchemaConfig } from './schema-manager';
+interface TrackerConfig {
+    endpoint: string;
+    autoTrack?: boolean;
+    debug?: boolean;
+}
+export declare class Tracker {
+    private eventManager;
+    private queueManager;
+    private strategyManager;
+    private schemaManager;
+    private isInitialized;
+    private debug;
+    constructor(config: TrackerConfig);
+    /**
+     * Safe execution wrapper to handle errors based on debug mode.
+     * @param fn Function to execute safely
+     */
+    private safeRun;
+    /**
+     * Load dynamic schema (IDL/JSON) for event validation.
+     * @param config Schema configuration
+     */
+    loadSchema(config: SchemaConfig): void;
+    /**
+     * Track an event.
+     * @param eventName Name of the event
+     * @param params Event parameters
+     * @param forcedImmediate Whether to send immediately (bypassing queue)
+     */
+    trackEvent<K extends keyof EventMap>(eventName: K, params: EventMap[K], forcedImmediate?: boolean): void;
+    trackEvent(eventName: string, params: Record<string, unknown>, forcedImmediate?: boolean): void;
+    private initAutoTracking;
+    private trackPageView;
+    private trackClicks;
+    private trackErrors;
+    private trackPerformance;
+    private setupUnload;
+}
+export {};