@sessionvision/core 0.2.0

package/dist/react/identity/session.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Session ID management
+ * Manages session lifecycle with configurable inactivity timeout
+ */
+/**
+ * Set the session timeout duration (for server-side configuration)
+ */
+export declare function setSessionTimeout(timeoutMinutes: number): void;
+/**
+ * Get the current session timeout in milliseconds
+ */
+export declare function getSessionTimeout(): number;
+/**
+ * Get or create a session ID
+ * Creates a new session if:
+ * - No existing session
+ * - Session has timed out (30 minutes of inactivity by default)
+ */
+export declare function getSessionId(): string;
+/**
+ * Force start a new session
+ */
+export declare function startNewSession(): string;
+/**
+ * Reset the session (clear storage and cache)
+ */
+export declare function resetSession(): string;
+/**
+ * Check if the current session has expired
+ */
+export declare function isSessionExpired(): boolean;
+/**
+ * Get the time remaining in the current session (in milliseconds)
+ * Returns 0 if session has expired
+ */
+export declare function getSessionTimeRemaining(): number;
+/**
+ * Touch the session to keep it alive
+ * Called on user activity
+ */
+export declare function touchSession(): void;
+/**
+ * Clear the in-memory cache (for testing)
+ */
+export declare function _clearCache(): void;
+/**
+ * Reset timeout to default (for testing)
+ */
+export declare function _resetTimeout(): void;

package/dist/react/index.cjs.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var sessionvision = require('@sessionvision/core');
+
+const SessionVisionContext = react.createContext(null);
+function useSessionVision() {
+    const context = react.useContext(SessionVisionContext);
+    if (!context) {
+        throw new Error('useSessionVision must be used within a SessionVisionProvider. ' +
+            'Wrap your app in <SessionVisionProvider apiKey="...">.');
+    }
+    return context;
+}
+
+function SessionVisionProvider({ apiKey, options, children }) {
+    react.useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        if (sessionvision.__SV)
+            return;
+        sessionvision.init(apiKey, options);
+        // options intentionally excluded - provider only reads them on mount
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [apiKey]);
+    return (jsxRuntime.jsx(SessionVisionContext.Provider, { value: sessionvision, children: children }));
+}
+
+function useCapture() {
+    const sessionvision = useSessionVision();
+    return react.useCallback((eventName, properties) => {
+        sessionvision.capture(eventName, properties);
+    }, [sessionvision]);
+}
+function useIdentify() {
+    const sessionvision = useSessionVision();
+    return react.useCallback((userId, traits) => {
+        sessionvision.identify(userId, traits);
+    }, [sessionvision]);
+}
+
+exports.SessionVisionContext = SessionVisionContext;
+exports.SessionVisionProvider = SessionVisionProvider;
+exports.useCapture = useCapture;
+exports.useIdentify = useIdentify;
+exports.useSessionVision = useSessionVision;
+//# sourceMappingURL=index.cjs.js.map

package/dist/react/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":["../../src/react/context.ts","../../src/react/SessionVisionProvider.tsx","../../src/react/hooks.ts"],"sourcesContent":[null,null,null],"names":["createContext","useContext","useEffect","_jsx","useCallback"],"mappings":";;;;;;MAGa,oBAAoB,GAAGA,mBAAa,CAA0B,IAAI;SAE/D,gBAAgB,GAAA;AAC9B,IAAA,MAAM,OAAO,GAAGC,gBAAU,CAAC,oBAAoB,CAAC;IAEhD,IAAI,CAAC,OAAO,EAAE;QACZ,MAAM,IAAI,KAAK,CACb,gEAAgE;AAC9D,YAAA,wDAAwD,CAC3D;IACH;AAEA,IAAA,OAAO,OAAO;AAChB;;ACJM,SAAU,qBAAqB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAA8B,EAAA;IAC7FC,eAAS,CAAC,MAAK;QACb,IAAI,OAAO,MAAM,KAAK,WAAW;YAAE;QACnC,IAAI,aAAa,CAAC,IAAI;YAAE;AAExB,QAAA,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC;;;AAGrC,IAAA,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;AAEZ,IAAA,QACEC,cAAA,CAAC,oBAAoB,CAAC,QAAQ,EAAA,EAAC,KAAK,EAAE,aAAa,EAAA,QAAA,EAChD,QAAQ,EAAA,CACqB;AAEpC;;SCvBgB,UAAU,GAAA;AACxB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAOC,iBAAW,CAChB,CAAC,SAAiB,EAAE,UAA4B,KAAI;AAClD,QAAA,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC;AAC9C,IAAA,CAAC,EACD,CAAC,aAAa,CAAC,CAChB;AACH;SAEgB,WAAW,GAAA;AACzB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAOA,iBAAW,CAChB,CAAC,MAAc,EAAE,MAAmB,KAAI;AACtC,QAAA,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;AACxC,IAAA,CAAC,EACD,CAAC,aAAa,CAAC,CAChB;AACH;;;;;;;;"}

package/dist/react/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session Vision JavaScript Snippet
+ * Main SDK entry point
+ *
+ * @version __SESSIONVISION_VERSION__
+ */
+import { SessionVisionConfig, EventProperties, UserTraits, SessionVisionAPI } from './types';
+/**
+ * Session Vision SDK instance
+ */
+declare const sessionvision: SessionVisionAPI;
+export default sessionvision;
+export type { SessionVisionConfig, EventProperties, UserTraits };

package/dist/react/index.esm.js

@@ -0,0 +1,42 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext, useEffect, useCallback } from 'react';
+import sessionvision from '@sessionvision/core';
+
+const SessionVisionContext = createContext(null);
+function useSessionVision() {
+    const context = useContext(SessionVisionContext);
+    if (!context) {
+        throw new Error('useSessionVision must be used within a SessionVisionProvider. ' +
+            'Wrap your app in <SessionVisionProvider apiKey="...">.');
+    }
+    return context;
+}
+
+function SessionVisionProvider({ apiKey, options, children }) {
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        if (sessionvision.__SV)
+            return;
+        sessionvision.init(apiKey, options);
+        // options intentionally excluded - provider only reads them on mount
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [apiKey]);
+    return (jsx(SessionVisionContext.Provider, { value: sessionvision, children: children }));
+}
+
+function useCapture() {
+    const sessionvision = useSessionVision();
+    return useCallback((eventName, properties) => {
+        sessionvision.capture(eventName, properties);
+    }, [sessionvision]);
+}
+function useIdentify() {
+    const sessionvision = useSessionVision();
+    return useCallback((userId, traits) => {
+        sessionvision.identify(userId, traits);
+    }, [sessionvision]);
+}
+
+export { SessionVisionContext, SessionVisionProvider, useCapture, useIdentify, useSessionVision };
+//# sourceMappingURL=index.esm.js.map

package/dist/react/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../../src/react/context.ts","../../src/react/SessionVisionProvider.tsx","../../src/react/hooks.ts"],"sourcesContent":[null,null,null],"names":["_jsx"],"mappings":";;;;MAGa,oBAAoB,GAAG,aAAa,CAA0B,IAAI;SAE/D,gBAAgB,GAAA;AAC9B,IAAA,MAAM,OAAO,GAAG,UAAU,CAAC,oBAAoB,CAAC;IAEhD,IAAI,CAAC,OAAO,EAAE;QACZ,MAAM,IAAI,KAAK,CACb,gEAAgE;AAC9D,YAAA,wDAAwD,CAC3D;IACH;AAEA,IAAA,OAAO,OAAO;AAChB;;ACJM,SAAU,qBAAqB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAA8B,EAAA;IAC7F,SAAS,CAAC,MAAK;QACb,IAAI,OAAO,MAAM,KAAK,WAAW;YAAE;QACnC,IAAI,aAAa,CAAC,IAAI;YAAE;AAExB,QAAA,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC;;;AAGrC,IAAA,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;AAEZ,IAAA,QACEA,GAAA,CAAC,oBAAoB,CAAC,QAAQ,EAAA,EAAC,KAAK,EAAE,aAAa,EAAA,QAAA,EAChD,QAAQ,EAAA,CACqB;AAEpC;;SCvBgB,UAAU,GAAA;AACxB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAO,WAAW,CAChB,CAAC,SAAiB,EAAE,UAA4B,KAAI;AAClD,QAAA,aAAa,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC;AAC9C,IAAA,CAAC,EACD,CAAC,aAAa,CAAC,CAChB;AACH;SAEgB,WAAW,GAAA;AACzB,IAAA,MAAM,aAAa,GAAG,gBAAgB,EAAE;AAExC,IAAA,OAAO,WAAW,CAChB,CAAC,MAAc,EAAE,MAAmB,KAAI;AACtC,QAAA,aAAa,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;AACxC,IAAA,CAAC,EACD,CAAC,aAAa,CAAC,CAChB;AACH;;;;"}

package/dist/react/react/SessionVisionProvider.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { SessionVisionConfig } from '../types';
+export interface SessionVisionProviderProps {
+    apiKey: string;
+    options?: Omit<SessionVisionConfig, 'apiHost'>;
+    children: ReactNode;
+}
+export declare function SessionVisionProvider({ apiKey, options, children }: SessionVisionProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/react/react/context.d.ts

@@ -0,0 +1,3 @@
+import type { SessionVisionAPI } from '../types';
+export declare const SessionVisionContext: import("react").Context<SessionVisionAPI | null>;
+export declare function useSessionVision(): SessionVisionAPI;

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

@@ -0,0 +1,3 @@
+import type { EventProperties, UserTraits } from '../types';
+export declare function useCapture(): (eventName: string, properties?: EventProperties) => void;
+export declare function useIdentify(): (userId: string, traits?: UserTraits) => void;

package/dist/react/react/index.d.ts

@@ -0,0 +1,4 @@
+export { SessionVisionProvider } from './SessionVisionProvider';
+export type { SessionVisionProviderProps } from './SessionVisionProvider';
+export { SessionVisionContext, useSessionVision } from './context';
+export { useCapture, useIdentify } from './hooks';

package/dist/react/stub.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Session Vision Inline Stub
+ *
+ * This is the minimal script that customers paste in their <head> tag.
+ * It creates the sessionvision global, queues method calls, and loads the main SDK.
+ *
+ * Target size: < 1KB minified
+ */
+export {};

package/dist/react/transport/buffer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Event buffer module
+ * Buffers events and flushes them periodically or when buffer is full
+ */
+import { CapturedEvent, ResolvedConfig } from '../types';
+/**
+ * Set the configuration
+ */
+export declare function setBufferConfig(cfg: ResolvedConfig): void;
+/**
+ * Add an event to the buffer
+ */
+export declare function addToBuffer(event: CapturedEvent): void;
+/**
+ * Flush the event buffer
+ * Sends all buffered events to the server
+ */
+export declare function flush(): Promise<void>;
+/**
+ * Start the flush timer
+ */
+export declare function startFlushTimer(): void;
+/**
+ * Stop the flush timer
+ */
+export declare function stopFlushTimer(): void;
+/**
+ * Initialize visibility change handler for flushing on tab hide
+ */
+export declare function initVisibilityHandler(): void;
+/**
+ * Get the current buffer size
+ */
+export declare function getBufferSize(): number;
+/**
+ * Check if the buffer is full
+ */
+export declare function isBufferFull(): boolean;
+/**
+ * Clear the buffer (for testing or shutdown)
+ */
+export declare function clearBuffer(): void;
+/**
+ * Get buffer contents (for testing)
+ */
+export declare function _getBuffer(): CapturedEvent[];
+/**
+ * Reset buffer state (for testing)
+ */
+export declare function _reset(): void;

package/dist/react/transport/compress.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Payload compression module
+ * Uses CompressionStream API when available
+ */
+/**
+ * Check if compression is supported
+ */
+export declare function isCompressionSupported(): boolean;
+/**
+ * Compress a string using gzip
+ * Returns the compressed data as a Blob, or null if compression is not supported
+ */
+export declare function compressPayload(data: string): Promise<Blob | null>;
+/**
+ * Get the size of data in bytes
+ */
+export declare function getByteSize(data: string): number;
+/**
+ * Check if payload should be compressed (based on size threshold)
+ * Only compress if payload is larger than 1KB
+ */
+export declare function shouldCompress(data: string): boolean;

package/dist/react/transport/send.d.ts

@@ -0,0 +1,30 @@
+/**
+ * HTTP transport module
+ * Handles sending events to the ingest API
+ */
+import { EventBatchPayload, ResolvedConfig } from '../types';
+/**
+ * Set the configuration
+ */
+export declare function setTransportConfig(cfg: ResolvedConfig): void;
+/**
+ * Send events to the ingest API
+ * Handles compression and retry logic
+ */
+export declare function sendEvents(payload: EventBatchPayload): Promise<boolean>;
+/**
+ * Get the number of consecutive failures
+ */
+export declare function getConsecutiveFailures(): number;
+/**
+ * Check if we should stop retrying (3+ consecutive failures)
+ */
+export declare function shouldStopRetrying(): boolean;
+/**
+ * Reset failure counter (for testing)
+ */
+export declare function _resetFailures(): void;
+/**
+ * Reset config (for testing)
+ */
+export declare function _resetConfig(): void;

package/dist/react/types.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Session Vision Snippet Type Definitions
+ */
+/**
+ * Autocapture configuration options
+ */
+export interface AutocaptureConfig {
+    /** Capture $pageview events (default: true) */
+    pageview?: boolean;
+    /** Capture $click events (default: true) */
+    clicks?: boolean;
+    /** Capture $form_submit events (default: true) */
+    formSubmit?: boolean;
+}
+/**
+ * SDK configuration options passed to init()
+ */
+export interface SessionVisionConfig {
+    /** CDN endpoint for SDK loading (default: 'https://cdn.sessionvision.com') */
+    apiHost?: string;
+    /** API endpoint for event ingestion and config (default: 'https://app.sessionvision.com') */
+    ingestHost?: string;
+    /** SDK version to load (default: 'latest') */
+    version?: string;
+    /** Enable console logging of all events (default: false) */
+    debug?: boolean;
+    /** Disable all tracking for consent management (default: false) */
+    optOut?: boolean;
+    /** Mask all input values in recordings (default: true) */
+    maskAllInputs?: boolean;
+    /** Enable/disable auto-capture (default: true) */
+    autocapture?: boolean | AutocaptureConfig;
+}
+/**
+ * Internal resolved configuration
+ */
+export interface ResolvedConfig {
+    projectToken: string;
+    apiHost: string;
+    ingestHost: string;
+    version: string;
+    debug: boolean;
+    optOut: boolean;
+    maskAllInputs: boolean;
+    autocapture: {
+        pageview: boolean;
+        clicks: boolean;
+        formSubmit: boolean;
+    };
+}
+/**
+ * Remote configuration fetched from server
+ */
+export interface RemoteConfig {
+    recording?: {
+        enabled: boolean;
+        sampleRate: number;
+    };
+    session?: {
+        timeoutMinutes: number;
+    };
+    version?: string;
+}
+/**
+ * User traits for identify()
+ */
+export interface UserTraits {
+    email?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+/**
+ * Event properties
+ */
+export interface EventProperties {
+    [key: string]: unknown;
+}
+/**
+ * Automatic properties attached to every event
+ */
+export interface AutomaticProperties {
+    $current_url: string;
+    $referrer: string;
+    $browser: string;
+    $browser_version: string;
+    $os: string;
+    $device_type: string;
+    $screen_width: number;
+    $screen_height: number;
+    $viewport_width: number;
+    $viewport_height: number;
+    $timezone: string;
+    $locale: string;
+    $connection_type: string | null;
+    $lib_version: string;
+}
+/**
+ * Internal event structure
+ */
+export interface CapturedEvent {
+    event: string;
+    timestamp: number;
+    properties: EventProperties & Partial<AutomaticProperties>;
+    anonymousId: string;
+    userId: string | null;
+    sessionId: string;
+}
+/**
+ * Event batch payload sent to server
+ */
+export interface EventBatchPayload {
+    projectToken: string;
+    events: CapturedEvent[];
+}
+/**
+ * Click event properties
+ */
+export interface ClickEventProperties extends EventProperties {
+    $element_tag: string;
+    $element_text: string;
+    $element_classes: string;
+    $element_id: string | null;
+    $element_selector: string;
+    $element_href: string | null;
+}
+/**
+ * Form submit event properties
+ */
+export interface FormSubmitEventProperties extends EventProperties {
+    $form_id: string | null;
+    $form_action: string;
+    $form_method: string;
+    $form_name: string | null;
+}
+/**
+ * Pageview event properties
+ */
+export interface PageviewEventProperties extends EventProperties {
+    $current_url: string;
+    $referrer: string;
+    $title: string;
+}
+/**
+ * Session data stored in sessionStorage
+ */
+export interface SessionData {
+    id: string;
+    lastActivity: number;
+}
+/**
+ * Identity data stored in localStorage
+ */
+export interface IdentityData {
+    anonymousId: string;
+    userId: string | null;
+}
+/**
+ * Registered properties stored in localStorage
+ */
+export interface RegisteredProperties {
+    [key: string]: unknown;
+}
+/**
+ * Queued method call before SDK loads
+ */
+export interface QueuedCall {
+    method: string;
+    args: unknown[];
+}
+/**
+ * Public API interface
+ */
+export interface SessionVisionAPI {
+    /** Initialize the SDK with project token and config */
+    init(projectToken: string, config?: SessionVisionConfig): void;
+    /** Capture a custom event */
+    capture(eventName: string, properties?: EventProperties): void;
+    /** Identify a user */
+    identify(userId: string, traits?: UserTraits): void;
+    /** Reset identity (for logout) */
+    reset(): void;
+    /** Get the current distinct ID (userId if identified, anonymousId otherwise) */
+    getDistinctId(): string;
+    /** Register properties to be sent with every event */
+    register(properties: EventProperties): void;
+    /** Register properties only if they don't already exist */
+    registerOnce(properties: EventProperties): void;
+    /** SDK version */
+    version: string;
+    /** Internal: queued method calls before SDK loads */
+    _q?: QueuedCall[];
+    /** Internal: init calls */
+    _i?: Array<[string, SessionVisionConfig?]>;
+    /** Internal: SDK version marker */
+    __SV?: number;
+}
+/**
+ * Storage key constants
+ */
+export declare const STORAGE_KEYS: {
+    readonly ANONYMOUS_ID: "sessionvision_anonymous_id";
+    readonly USER_ID: "sessionvision_user_id";
+    readonly SESSION: "sessionvision_session";
+    readonly REGISTERED_PROPS: "sessionvision_registered";
+    readonly REGISTERED_ONCE_PROPS: "sessionvision_registered_once";
+    readonly CONFIG_CACHE: "sessionvision_config";
+};
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_CONFIG: Omit<ResolvedConfig, 'projectToken'>;
+/**
+ * Session timeout in milliseconds (30 minutes)
+ */
+export declare const SESSION_TIMEOUT_MS: number;
+/**
+ * Event buffer configuration
+ */
+export declare const BUFFER_CONFIG: {
+    readonly MAX_EVENTS: 10;
+    readonly FLUSH_INTERVAL_MS: 5000;
+    readonly MAX_RETRIES: 3;
+    readonly RETRY_DELAYS_MS: readonly [1000, 2000, 4000];
+};
+/**
+ * Config cache TTL in milliseconds (1 hour)
+ */
+export declare const CONFIG_CACHE_TTL_MS: number;

package/dist/react/utils/dom.d.ts

@@ -0,0 +1,51 @@
+/**
+ * DOM utility functions for element inspection and event handling
+ */
+/**
+ * Get the visible text content of an element, truncated to maxLength
+ */
+export declare function getElementText(element: Element, maxLength?: number): string;
+/**
+ * Get CSS classes of an element as a space-separated string
+ */
+export declare function getElementClasses(element: Element): string;
+/**
+ * Get the tag name of an element in lowercase
+ */
+export declare function getElementTag(element: Element): string;
+/**
+ * Get the ID of an element, or null if not present
+ */
+export declare function getElementId(element: Element): string | null;
+/**
+ * Get the href attribute for anchor elements
+ */
+export declare function getElementHref(element: Element): string | null;
+/**
+ * Check if an element should be ignored for tracking
+ */
+export declare function shouldIgnoreElement(element: Element): boolean;
+/**
+ * Check if an element is interactive (clickable, input, etc.)
+ */
+export declare function isInteractiveElement(element: Element): boolean;
+/**
+ * Get the closest interactive parent element
+ */
+export declare function getInteractiveParent(element: Element): Element | null;
+/**
+ * Safe document ready check
+ */
+export declare function onDocumentReady(callback: () => void): void;
+/**
+ * Get the current page URL
+ */
+export declare function getCurrentUrl(): string;
+/**
+ * Get the document referrer
+ */
+export declare function getReferrer(): string;
+/**
+ * Get the document title
+ */
+export declare function getDocumentTitle(): string;

package/dist/react/utils/pii.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PII (Personally Identifiable Information) detection utility
+ * Detects and masks sensitive data patterns in text
+ */
+/**
+ * Check if text contains PII
+ */
+export declare function containsPII(text: string): boolean;
+/**
+ * Mask PII in text
+ */
+export declare function maskPII(text: string): string;
+/**
+ * Detect which types of PII are present in text
+ */
+export declare function detectPIITypes(text: string): string[];
+/**
+ * Check if a string looks like a password field value
+ * (all masked characters or very short alphanumeric)
+ */
+export declare function looksLikePassword(value: string): boolean;
+/**
+ * Safely mask a value that might be sensitive
+ * Returns masked version if PII detected, original otherwise
+ */
+export declare function safeMaskValue(value: string, alwaysMask?: boolean): string;

package/dist/react/utils/selector.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CSS Selector generation utility
+ * Generates stable, unique selectors for DOM elements
+ */
+/**
+ * Generate a CSS selector for an element
+ * Priority:
+ * 1. data-sessionvision-id attribute
+ * 2. ID attribute (if unique)
+ * 3. Path-based selector with classes
+ */
+export declare function generateSelector(element: Element): string;

package/dist/react/utils/storage.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Storage utility for localStorage and sessionStorage operations
+ * Provides safe access with error handling for environments where storage is unavailable
+ */
+/**
+ * Check if localStorage is available
+ */
+export declare function isLocalStorageAvailable(): boolean;
+/**
+ * Check if sessionStorage is available
+ */
+export declare function isSessionStorageAvailable(): boolean;
+/**
+ * Get a value from localStorage
+ */
+export declare function getLocalStorage<T>(key: string): T | null;
+/**
+ * Set a value in localStorage
+ */
+export declare function setLocalStorage<T>(key: string, value: T): boolean;
+/**
+ * Remove a value from localStorage
+ */
+export declare function removeLocalStorage(key: string): boolean;
+/**
+ * Get a value from sessionStorage
+ */
+export declare function getSessionStorage<T>(key: string): T | null;
+/**
+ * Set a value in sessionStorage
+ */
+export declare function setSessionStorage<T>(key: string, value: T): boolean;
+/**
+ * Remove a value from sessionStorage
+ */
+export declare function removeSessionStorage(key: string): boolean;
+/**
+ * Get a raw string value from localStorage (without JSON parsing)
+ */
+export declare function getLocalStorageRaw(key: string): string | null;
+/**
+ * Set a raw string value in localStorage (without JSON stringifying)
+ */
+export declare function setLocalStorageRaw(key: string, value: string): boolean;

package/dist/react/utils/uuid.d.ts

@@ -0,0 +1,13 @@
+/**
+ * UUID v4 generation utility
+ * Generates cryptographically random UUIDs when available, falls back to Math.random
+ */
+/**
+ * Generate a UUID v4 string
+ * Uses crypto.randomUUID() when available, falls back to manual generation
+ */
+export declare function generateUUID(): string;
+/**
+ * Validate a UUID string format
+ */
+export declare function isValidUUID(uuid: string): boolean;