@selwise/react-native 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Selwise } from './selwise';
+export type { AsyncStorageLike, ConsentCategories, ConsentState, IdentifyResult, JourneyState, RecommendationProductsContext, RecommendationWidgetQuery, ScreenContext, SearchOptions, SelwiseDataLayer, SelwiseReactNativeConfig, TrackArgs, TrackOrderInput, TrackOrderItem, } from './types';
+export { Selwise as default } from './selwise';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.Selwise = void 0;
+var selwise_1 = require("./selwise");
+Object.defineProperty(exports, "Selwise", { enumerable: true, get: function () { return selwise_1.Selwise; } });
+var selwise_2 = require("./selwise");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return selwise_2.Selwise; } });

package/dist/selwise.d.ts

@@ -0,0 +1,59 @@
+import type { ConsentCategories, ConsentState, IdentifyResult, JourneyState, RecommendationProductsContext, RecommendationWidgetQuery, ScreenContext, SearchOptions, SelwiseDataLayer, SelwiseReactNativeConfig, TrackArgs, TrackOrderInput } from './types';
+export declare class Selwise {
+    private runtimeConfig;
+    private storage;
+    private transport;
+    private identityState;
+    private queue;
+    private flushTimer;
+    private appStateSubscription;
+    private readonly activeExperiments;
+    private queueStorageKey;
+    private stateStorageKey;
+    private initialized;
+    private isFlushing;
+    init(config: SelwiseReactNativeConfig): Promise<void>;
+    destroy(): void;
+    track(name: string, args?: TrackArgs): void;
+    trackOrder(order: TrackOrderInput): Promise<void>;
+    identify(userId: string, metadata?: Record<string, unknown>): Promise<IdentifyResult>;
+    setTraits(traits: Record<string, unknown>): Promise<boolean>;
+    getVisitorId(): string;
+    getSessionId(): string;
+    getJourneyId(): string | null;
+    getJourneyState(): JourneyState;
+    endJourney(): void;
+    getVariant(experimentId: string): unknown;
+    getExperimentVariant(experimentId: string): string | null;
+    getActiveExperiments(): unknown[];
+    pushDataLayer(data: SelwiseDataLayer): void;
+    getDataLayer(): SelwiseDataLayer[];
+    getConsentState(): ConsentState | null;
+    grantConsent(categories?: Partial<ConsentState>): void;
+    revokeConsent(categories?: (keyof ConsentCategories)[]): void;
+    flush(): Promise<void>;
+    setScreenContext(context: ScreenContext): void;
+    getSiteConfig(): Promise<Record<string, unknown>>;
+    getSearchConfig(): Promise<Record<string, unknown>>;
+    search(query: string, options?: SearchOptions): Promise<Record<string, unknown>>;
+    getSearchSuggestions(): Promise<Record<string, unknown>>;
+    getRecommendationWidgets(query?: RecommendationWidgetQuery): Promise<Record<string, unknown>>;
+    getRecommendationProducts(widgetId: string, context?: RecommendationProductsContext): Promise<Record<string, unknown>>;
+    private normalizeConfig;
+    private ensureIdentityState;
+    private enqueueEvent;
+    private ensureJourney;
+    private startFlushTimer;
+    private stopFlushTimer;
+    private attachAppStateFlush;
+    private syncConsent;
+    private mergeConsentCategories;
+    private defaultConsentState;
+    private getSdkMetadata;
+    private captureExperimentAssignments;
+    private requestPublicGet;
+    private loadIdentityState;
+    private loadQueue;
+    private persistIdentityState;
+    private persistQueue;
+}

package/dist/selwise.js

@@ -0,0 +1,647 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Selwise = void 0;
+const storage_1 = require("./storage");
+const transport_1 = require("./transport");
+const utils_1 = require("./utils");
+const DEFAULT_API_URL = 'https://api.selwise.com/api/v1';
+const DEFAULT_PLATFORM = 'react-native';
+const DEFAULT_VERSION = '0.1.0';
+const DEFAULT_FLUSH_INTERVAL_MS = 15000;
+const DEFAULT_BATCH_SIZE = 25;
+const DEFAULT_MAX_RETRIES = 5;
+const DEFAULT_MAX_QUEUE_SIZE = 500;
+const DEFAULT_JOURNEY_TTL_MS = 30 * 60 * 1000;
+const DEFAULT_STORAGE_PREFIX = 'selwise_rn';
+const MAX_DATALAYER_ITEMS = 500;
+class Selwise {
+    constructor() {
+        this.runtimeConfig = null;
+        this.storage = null;
+        this.transport = null;
+        this.identityState = null;
+        this.queue = [];
+        this.flushTimer = null;
+        this.appStateSubscription = null;
+        this.activeExperiments = new Map();
+        this.queueStorageKey = null;
+        this.stateStorageKey = null;
+        this.initialized = false;
+        this.isFlushing = false;
+    }
+    async init(config) {
+        const normalized = this.normalizeConfig(config);
+        this.runtimeConfig = normalized;
+        this.stateStorageKey = `${normalized.storagePrefix}:${normalized.siteKey}:state`;
+        this.queueStorageKey = `${normalized.storagePrefix}:${normalized.siteKey}:queue`;
+        this.storage = (0, storage_1.resolveAsyncStorage)(config.storage);
+        this.transport = new transport_1.SelwiseTransport({
+            baseUrl: normalized.apiUrl,
+            siteKey: normalized.siteKey,
+            apiKey: normalized.apiKey,
+            sdkPlatform: normalized.sdkPlatform,
+            sdkVersion: normalized.sdkVersion,
+        });
+        this.identityState = await this.loadIdentityState();
+        this.identityState = this.ensureIdentityState(this.identityState);
+        this.queue = await this.loadQueue();
+        await Promise.all([this.persistIdentityState(), this.persistQueue()]);
+        this.attachAppStateFlush();
+        this.startFlushTimer();
+        this.initialized = true;
+    }
+    destroy() {
+        void this.flush();
+        this.stopFlushTimer();
+        if (this.appStateSubscription) {
+            this.appStateSubscription.remove();
+            this.appStateSubscription = null;
+        }
+        this.initialized = false;
+    }
+    track(name, args) {
+        if (!this.initialized || !this.runtimeConfig || !this.identityState) {
+            return;
+        }
+        const now = Date.now();
+        const event = {
+            eventId: (0, utils_1.createEventId)(),
+            eventSchemaVersion: 1,
+            eventTs: now,
+            timestamp: now,
+            name,
+            entityType: args?.entityType || 'custom',
+            entityId: args?.entityId,
+            metadata: {
+                ...((0, utils_1.sanitizeMetadata)(args?.metadata) || {}),
+                ...(this.identityState.screenContext
+                    ? {
+                        screenName: this.identityState.screenContext.name,
+                        screenPath: this.identityState.screenContext.path,
+                    }
+                    : {}),
+            },
+            retryCount: 0,
+            nextAttemptAt: now,
+        };
+        this.enqueueEvent(event);
+    }
+    async trackOrder(order) {
+        if (!this.initialized || !this.transport || !this.identityState || !this.runtimeConfig) {
+            return;
+        }
+        const orderId = (order.orderId || '').trim();
+        if (!orderId) {
+            return;
+        }
+        const sdkMetadata = this.getSdkMetadata();
+        await this.transport.request(`/public/sites/${this.runtimeConfig.siteKey}/orders`, {
+            method: 'POST',
+            body: {
+                ...order,
+                orderId,
+                sessionId: this.identityState.sessionId,
+                visitorId: order.visitorId || this.identityState.visitorId,
+                siteUserId: order.siteUserId || this.identityState.siteUserId,
+                pageUrl: this.identityState.screenContext?.path,
+                referrer: this.identityState.screenContext?.referrer,
+                metadata: {
+                    ...(order.metadata || {}),
+                    ...sdkMetadata,
+                },
+            },
+        });
+    }
+    async identify(userId, metadata) {
+        if (!this.initialized || !this.transport || !this.identityState || !this.runtimeConfig) {
+            return { success: false, merged: false };
+        }
+        const externalId = (userId || '').trim();
+        if (!externalId) {
+            return { success: false, merged: false };
+        }
+        this.identityState.siteUserId = externalId;
+        await this.persistIdentityState();
+        try {
+            const result = await this.transport.request(`/public/sites/${this.runtimeConfig.siteKey}/users/identify`, {
+                method: 'POST',
+                body: {
+                    externalId,
+                    visitorId: this.identityState.visitorId,
+                    sessionId: this.identityState.sessionId,
+                    traits: metadata,
+                    pageUrl: this.identityState.screenContext?.path,
+                    referrer: this.identityState.screenContext?.referrer,
+                    userAgent: 'react-native',
+                },
+            });
+            return result;
+        }
+        catch {
+            return { success: false, merged: false };
+        }
+    }
+    async setTraits(traits) {
+        if (!this.initialized || !this.transport || !this.identityState || !this.runtimeConfig) {
+            return false;
+        }
+        try {
+            const result = await this.transport.request(`/public/sites/${this.runtimeConfig.siteKey}/users/traits`, {
+                method: 'POST',
+                body: {
+                    externalId: this.identityState.siteUserId,
+                    visitorId: this.identityState.siteUserId ? undefined : this.identityState.visitorId,
+                    traits,
+                },
+            });
+            return result.success === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getVisitorId() {
+        if (!this.initialized) {
+            return '';
+        }
+        return this.identityState?.visitorId || '';
+    }
+    getSessionId() {
+        if (!this.initialized) {
+            return '';
+        }
+        return this.identityState?.sessionId || '';
+    }
+    getJourneyId() {
+        if (!this.initialized || !this.identityState || !this.runtimeConfig) {
+            return null;
+        }
+        const age = Date.now() - this.identityState.journeyCreatedAt;
+        if (age >= this.runtimeConfig.journeyTtlMs) {
+            return null;
+        }
+        return this.identityState.journeyId;
+    }
+    getJourneyState() {
+        if (!this.initialized || !this.identityState || !this.runtimeConfig) {
+            return {
+                journeyId: null,
+                age: null,
+                isValid: false,
+            };
+        }
+        const age = Date.now() - this.identityState.journeyCreatedAt;
+        return {
+            journeyId: this.identityState.journeyId,
+            age,
+            isValid: age < this.runtimeConfig.journeyTtlMs,
+        };
+    }
+    endJourney() {
+        if (!this.initialized || !this.identityState) {
+            return;
+        }
+        this.identityState.journeyId = (0, utils_1.createJourneyId)(this.identityState.visitorId);
+        this.identityState.journeyCreatedAt = Date.now();
+        void this.persistIdentityState();
+    }
+    getVariant(experimentId) {
+        return this.activeExperiments.get(experimentId);
+    }
+    getExperimentVariant(experimentId) {
+        const assignment = this.activeExperiments.get(experimentId);
+        if (!assignment) {
+            return null;
+        }
+        if (typeof assignment === 'string') {
+            return assignment;
+        }
+        return assignment.variantId || assignment.id || null;
+    }
+    getActiveExperiments() {
+        return Array.from(this.activeExperiments.values());
+    }
+    pushDataLayer(data) {
+        if (!this.initialized || !this.identityState) {
+            return;
+        }
+        this.identityState.dataLayer.push(data);
+        if (this.identityState.dataLayer.length > MAX_DATALAYER_ITEMS) {
+            this.identityState.dataLayer = this.identityState.dataLayer.slice(this.identityState.dataLayer.length - MAX_DATALAYER_ITEMS);
+        }
+        void this.persistIdentityState();
+    }
+    getDataLayer() {
+        if (!this.initialized) {
+            return [];
+        }
+        return this.identityState?.dataLayer || [];
+    }
+    getConsentState() {
+        if (!this.initialized) {
+            return null;
+        }
+        return this.identityState?.consentState || null;
+    }
+    grantConsent(categories) {
+        if (!this.initialized || !this.identityState) {
+            return;
+        }
+        const base = this.identityState.consentState || this.defaultConsentState();
+        const nextCategories = this.mergeConsentCategories(base.categories, categories);
+        this.identityState.consentState = {
+            granted: nextCategories.analytics || nextCategories.marketing || nextCategories.preferences,
+            timestamp: Date.now(),
+            categories: nextCategories,
+        };
+        void this.persistIdentityState();
+        void this.syncConsent('granted');
+    }
+    revokeConsent(categories) {
+        if (!this.initialized || !this.identityState) {
+            return;
+        }
+        const base = this.identityState.consentState || this.defaultConsentState();
+        const nextCategories = {
+            ...base.categories,
+            necessary: true,
+            analytics: categories ? base.categories.analytics : false,
+            marketing: categories ? base.categories.marketing : false,
+            preferences: categories ? base.categories.preferences : false,
+        };
+        if (categories && categories.length > 0) {
+            for (const category of categories) {
+                if (category !== 'necessary') {
+                    nextCategories[category] = false;
+                }
+            }
+        }
+        this.identityState.consentState = {
+            granted: nextCategories.analytics || nextCategories.marketing || nextCategories.preferences,
+            timestamp: Date.now(),
+            categories: nextCategories,
+        };
+        void this.persistIdentityState();
+        void this.syncConsent('revoked');
+    }
+    async flush() {
+        const runtimeConfig = this.runtimeConfig;
+        if (!this.initialized || !this.transport || !this.identityState || !runtimeConfig || this.isFlushing) {
+            return;
+        }
+        this.isFlushing = true;
+        try {
+            while (true) {
+                const now = Date.now();
+                const readyEvents = this.queue
+                    .filter((event) => event.nextAttemptAt <= now)
+                    .sort((a, b) => a.timestamp - b.timestamp)
+                    .slice(0, runtimeConfig.batchSize);
+                if (readyEvents.length === 0) {
+                    break;
+                }
+                try {
+                    const journeyId = this.ensureJourney();
+                    await this.transport.request(`/public/sites/${runtimeConfig.siteKey}/events/batch`, {
+                        method: 'POST',
+                        body: {
+                            sessionId: this.identityState.sessionId,
+                            visitorId: this.identityState.visitorId,
+                            siteUserId: this.identityState.siteUserId,
+                            journeyId,
+                            pageUrl: this.identityState.screenContext?.path,
+                            referrer: this.identityState.screenContext?.referrer,
+                            events: readyEvents.map((event) => ({
+                                eventId: event.eventId,
+                                eventSchemaVersion: event.eventSchemaVersion,
+                                eventTs: event.eventTs,
+                                name: event.name,
+                                entityType: event.entityType,
+                                entityId: event.entityId,
+                                metadata: event.metadata,
+                            })),
+                        },
+                    });
+                    const flushedIds = new Set(readyEvents.map((event) => event.eventId));
+                    this.queue = this.queue.filter((event) => !flushedIds.has(event.eventId));
+                    await Promise.all([this.persistQueue(), this.persistIdentityState()]);
+                }
+                catch {
+                    const failedIds = new Set(readyEvents.map((event) => event.eventId));
+                    this.queue = this.queue.map((event) => {
+                        if (!failedIds.has(event.eventId)) {
+                            return event;
+                        }
+                        const nextRetryCount = event.retryCount + 1;
+                        if (nextRetryCount > runtimeConfig.maxRetries) {
+                            return {
+                                ...event,
+                                retryCount: nextRetryCount,
+                                nextAttemptAt: Number.POSITIVE_INFINITY,
+                            };
+                        }
+                        const backoffMs = Math.min(1000 * 2 ** nextRetryCount, 60000);
+                        return {
+                            ...event,
+                            retryCount: nextRetryCount,
+                            nextAttemptAt: Date.now() + backoffMs,
+                        };
+                    });
+                    this.queue = this.queue.filter((event) => event.retryCount <= runtimeConfig.maxRetries);
+                    await this.persistQueue();
+                    break;
+                }
+            }
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    setScreenContext(context) {
+        if (!this.initialized || !this.identityState) {
+            return;
+        }
+        this.identityState.screenContext = {
+            name: context.name,
+            path: context.path,
+            referrer: context.referrer,
+        };
+        void this.persistIdentityState();
+    }
+    async getSiteConfig() {
+        const data = await this.requestPublicGet('/config');
+        this.captureExperimentAssignments(data);
+        return data;
+    }
+    async getSearchConfig() {
+        return this.requestPublicGet('/search-config');
+    }
+    async search(query, options) {
+        return this.requestPublicGet('/search', {
+            q: query,
+            ...options,
+        });
+    }
+    async getSearchSuggestions() {
+        return this.requestPublicGet('/search/suggestions');
+    }
+    async getRecommendationWidgets(query) {
+        return this.requestPublicGet('/recommendations', {
+            pageUrl: query?.pageUrl || this.identityState?.screenContext?.path,
+        });
+    }
+    async getRecommendationProducts(widgetId, context) {
+        if (!this.initialized || !this.transport || !this.runtimeConfig || !this.identityState) {
+            throw new Error('Selwise is not initialized');
+        }
+        return this.transport.request(`/public/sites/${this.runtimeConfig.siteKey}/recommendations/${widgetId}/products`, {
+            method: 'POST',
+            body: {
+                currentProductId: context?.currentProductId,
+                sessionId: context?.sessionId || this.identityState.sessionId,
+                visitorId: context?.visitorId || this.identityState.visitorId,
+                userId: context?.userId || this.identityState.siteUserId,
+            },
+        });
+    }
+    normalizeConfig(config) {
+        if (!config.siteKey || config.siteKey.trim().length === 0) {
+            throw new Error('siteKey is required');
+        }
+        if (!config.apiKey || config.apiKey.trim().length === 0) {
+            throw new Error('apiKey is required');
+        }
+        return {
+            siteKey: config.siteKey,
+            apiKey: config.apiKey,
+            apiUrl: config.apiUrl || DEFAULT_API_URL,
+            sdkPlatform: config.sdkPlatform || DEFAULT_PLATFORM,
+            sdkVersion: config.sdkVersion || DEFAULT_VERSION,
+            flushIntervalMs: config.flushIntervalMs || DEFAULT_FLUSH_INTERVAL_MS,
+            batchSize: config.batchSize || DEFAULT_BATCH_SIZE,
+            maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+            maxQueueSize: config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
+            journeyTtlMs: config.journeyTtlMs ?? DEFAULT_JOURNEY_TTL_MS,
+            storagePrefix: config.storagePrefix || DEFAULT_STORAGE_PREFIX,
+        };
+    }
+    ensureIdentityState(state) {
+        const visitorId = state?.visitorId || (0, utils_1.randomId)('vid');
+        const sessionId = state?.sessionId || (0, utils_1.randomId)('sid');
+        const nextState = {
+            visitorId,
+            sessionId,
+            journeyId: state?.journeyId || (0, utils_1.createJourneyId)(visitorId),
+            journeyCreatedAt: state?.journeyCreatedAt || Date.now(),
+            siteUserId: state?.siteUserId,
+            dataLayer: Array.isArray(state?.dataLayer) ? state.dataLayer : [],
+            consentState: state?.consentState || null,
+            screenContext: state?.screenContext || null,
+        };
+        if (Date.now() - nextState.journeyCreatedAt >=
+            (this.runtimeConfig?.journeyTtlMs || DEFAULT_JOURNEY_TTL_MS)) {
+            nextState.journeyId = (0, utils_1.createJourneyId)(nextState.visitorId);
+            nextState.journeyCreatedAt = Date.now();
+        }
+        return nextState;
+    }
+    enqueueEvent(event) {
+        if (!this.runtimeConfig) {
+            return;
+        }
+        this.queue.push(event);
+        if (this.queue.length > this.runtimeConfig.maxQueueSize) {
+            this.queue = this.queue.slice(this.queue.length - this.runtimeConfig.maxQueueSize);
+        }
+        void this.persistQueue();
+        if (this.queue.length >= this.runtimeConfig.batchSize) {
+            void this.flush();
+        }
+    }
+    ensureJourney() {
+        if (!this.identityState || !this.runtimeConfig) {
+            return '';
+        }
+        const age = Date.now() - this.identityState.journeyCreatedAt;
+        if (age >= this.runtimeConfig.journeyTtlMs) {
+            this.identityState.journeyId = (0, utils_1.createJourneyId)(this.identityState.visitorId);
+            this.identityState.journeyCreatedAt = Date.now();
+        }
+        return this.identityState.journeyId;
+    }
+    startFlushTimer() {
+        if (!this.runtimeConfig) {
+            return;
+        }
+        this.stopFlushTimer();
+        this.flushTimer = setInterval(() => {
+            void this.flush();
+        }, this.runtimeConfig.flushIntervalMs);
+    }
+    stopFlushTimer() {
+        if (!this.flushTimer) {
+            return;
+        }
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+    }
+    attachAppStateFlush() {
+        if (this.appStateSubscription) {
+            this.appStateSubscription.remove();
+            this.appStateSubscription = null;
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const rn = require('react-native');
+            const appState = rn?.AppState;
+            if (appState?.addEventListener) {
+                this.appStateSubscription = appState.addEventListener('change', (nextState) => {
+                    if (nextState !== 'active') {
+                        void this.flush();
+                    }
+                });
+            }
+        }
+        catch {
+            // AppState is optional in non-RN test environments.
+        }
+    }
+    async syncConsent(action) {
+        if (!this.transport ||
+            !this.identityState ||
+            !this.runtimeConfig ||
+            !this.identityState.consentState) {
+            return;
+        }
+        const body = {
+            categories: this.identityState.consentState.categories,
+            visitorId: this.identityState.visitorId,
+            sessionId: this.identityState.sessionId,
+            siteUserId: this.identityState.siteUserId,
+            action,
+        };
+        try {
+            if (action === 'granted') {
+                await this.transport.request(`/public/sites/${this.runtimeConfig.siteKey}/consent`, {
+                    method: 'POST',
+                    body,
+                });
+                return;
+            }
+            await this.transport.request(`/public/sites/${this.runtimeConfig.siteKey}/consent`, {
+                method: 'DELETE',
+                body,
+            });
+        }
+        catch {
+            // Best effort; consent state is still persisted locally.
+        }
+    }
+    mergeConsentCategories(base, override) {
+        const raw = override?.categories;
+        const flat = (!raw ? override : raw) || {};
+        return {
+            necessary: true,
+            analytics: flat.analytics ?? base.analytics,
+            marketing: flat.marketing ?? base.marketing,
+            preferences: flat.preferences ?? base.preferences,
+        };
+    }
+    defaultConsentState() {
+        return {
+            granted: false,
+            timestamp: Date.now(),
+            categories: {
+                necessary: true,
+                analytics: false,
+                marketing: false,
+                preferences: false,
+            },
+        };
+    }
+    getSdkMetadata() {
+        if (!this.runtimeConfig) {
+            return {};
+        }
+        return {
+            sdkPlatform: this.runtimeConfig.sdkPlatform,
+            sdkVersion: this.runtimeConfig.sdkVersion,
+        };
+    }
+    captureExperimentAssignments(data) {
+        const assignments = data.experiments;
+        if (!Array.isArray(assignments)) {
+            return;
+        }
+        this.activeExperiments.clear();
+        for (const assignment of assignments) {
+            if (!assignment || typeof assignment !== 'object') {
+                continue;
+            }
+            const record = assignment;
+            const experimentId = typeof record.experimentId === 'string'
+                ? record.experimentId
+                : typeof record.id === 'string'
+                    ? record.id
+                    : undefined;
+            if (!experimentId) {
+                continue;
+            }
+            this.activeExperiments.set(experimentId, assignment);
+        }
+    }
+    async requestPublicGet(suffix, query) {
+        if (!this.initialized || !this.transport || !this.runtimeConfig) {
+            throw new Error('Selwise is not initialized');
+        }
+        return this.transport.request(`/public/sites/${this.runtimeConfig.siteKey}${suffix}`, {
+            method: 'GET',
+            query,
+        });
+    }
+    async loadIdentityState() {
+        if (!this.storage || !this.stateStorageKey) {
+            return null;
+        }
+        try {
+            const value = await this.storage.getItem(this.stateStorageKey);
+            if (!value) {
+                return null;
+            }
+            const parsed = JSON.parse(value);
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    async loadQueue() {
+        if (!this.storage || !this.queueStorageKey) {
+            return [];
+        }
+        try {
+            const value = await this.storage.getItem(this.queueStorageKey);
+            if (!value) {
+                return [];
+            }
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    async persistIdentityState() {
+        if (!this.storage || !this.stateStorageKey || !this.identityState) {
+            return;
+        }
+        await this.storage.setItem(this.stateStorageKey, JSON.stringify(this.identityState));
+    }
+    async persistQueue() {
+        if (!this.storage || !this.queueStorageKey) {
+            return;
+        }
+        await this.storage.setItem(this.queueStorageKey, JSON.stringify(this.queue));
+    }
+}
+exports.Selwise = Selwise;

package/dist/storage.d.ts

@@ -0,0 +1,3 @@
+import type { AsyncStorageLike } from './types';
+export declare function createInMemoryStorage(): AsyncStorageLike;
+export declare function resolveAsyncStorage(providedStorage?: AsyncStorageLike): AsyncStorageLike;

package/dist/storage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInMemoryStorage = createInMemoryStorage;
+exports.resolveAsyncStorage = resolveAsyncStorage;
+class InMemoryStorage {
+    constructor() {
+        this.store = new Map();
+    }
+    async getItem(key) {
+        return this.store.has(key) ? this.store.get(key) : null;
+    }
+    async setItem(key, value) {
+        this.store.set(key, value);
+    }
+    async removeItem(key) {
+        this.store.delete(key);
+    }
+}
+function createInMemoryStorage() {
+    return new InMemoryStorage();
+}
+function resolveAsyncStorage(providedStorage) {
+    if (providedStorage) {
+        return providedStorage;
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const moduleValue = require('@react-native-async-storage/async-storage');
+        const candidate = moduleValue?.default || moduleValue;
+        if (candidate &&
+            typeof candidate.getItem === 'function' &&
+            typeof candidate.setItem === 'function' &&
+            typeof candidate.removeItem === 'function') {
+            return candidate;
+        }
+    }
+    catch {
+        // Ignore and fallback to in-memory storage.
+    }
+    return createInMemoryStorage();
+}

package/dist/transport.d.ts

@@ -0,0 +1,22 @@
+export interface TransportRequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    query?: Record<string, unknown>;
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+export declare class SelwiseTransport {
+    private readonly baseUrl;
+    private readonly siteKey;
+    private readonly apiKey;
+    private readonly sdkPlatform;
+    private readonly sdkVersion;
+    constructor(args: {
+        baseUrl: string;
+        siteKey: string;
+        apiKey: string;
+        sdkPlatform: string;
+        sdkVersion: string;
+    });
+    getSiteKey(): string;
+    request<T = unknown>(path: string, options?: TransportRequestOptions): Promise<T>;
+}

package/dist/transport.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelwiseTransport = void 0;
+const utils_1 = require("./utils");
+class SelwiseTransport {
+    constructor(args) {
+        this.baseUrl = (0, utils_1.stripTrailingSlash)(args.baseUrl);
+        this.siteKey = args.siteKey;
+        this.apiKey = args.apiKey;
+        this.sdkPlatform = args.sdkPlatform;
+        this.sdkVersion = args.sdkVersion;
+    }
+    getSiteKey() {
+        return this.siteKey;
+    }
+    async request(path, options = {}) {
+        if (typeof fetch !== 'function') {
+            throw new Error('Global fetch is required for @selwise/react-native');
+        }
+        const url = `${this.baseUrl}${path}${(0, utils_1.toQueryString)(options.query || {})}`;
+        const method = options.method || 'GET';
+        const response = await fetch(url, {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-selwise-api-key': this.apiKey,
+                'x-selwise-client-platform': this.sdkPlatform,
+                'x-selwise-client-version': this.sdkVersion,
+                ...(options.headers || {}),
+            },
+            body: options.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        if (response.status === 204) {
+            return undefined;
+        }
+        const text = await response.text();
+        const payload = text ? JSON.parse(text) : {};
+        if (!response.ok) {
+            const error = new Error(`Request failed: ${response.status}`);
+            error.status = response.status;
+            error.payload = payload;
+            throw error;
+        }
+        return payload;
+    }
+}
+exports.SelwiseTransport = SelwiseTransport;

package/dist/types.d.ts

@@ -0,0 +1,113 @@
+export interface AsyncStorageLike {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export interface SelwiseDataLayer {
+    [key: string]: unknown;
+}
+export interface ConsentCategories {
+    necessary: boolean;
+    analytics: boolean;
+    marketing: boolean;
+    preferences: boolean;
+}
+export interface ConsentState {
+    granted: boolean;
+    timestamp: number;
+    categories: ConsentCategories;
+}
+export interface ScreenContext {
+    name: string;
+    path: string;
+    referrer?: string;
+}
+export interface TrackArgs {
+    entityType?: string;
+    entityId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TrackOrderItem {
+    productItemCode?: string;
+    name?: string;
+    quantity?: number;
+    unitPrice?: number;
+    totalPrice?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface TrackOrderInput {
+    orderId: string;
+    currency?: string;
+    total?: number;
+    subtotal?: number;
+    discountTotal?: number;
+    shippingTotal?: number;
+    taxTotal?: number;
+    status?: string;
+    placedAt?: string;
+    visitorId?: string;
+    siteUserId?: string;
+    metadata?: Record<string, unknown>;
+    items?: TrackOrderItem[];
+}
+export interface SearchOptions {
+    limit?: number;
+    minPrice?: number;
+    maxPrice?: number;
+    inStock?: boolean;
+    category?: string;
+}
+export interface RecommendationWidgetQuery {
+    pageUrl?: string;
+}
+export interface RecommendationProductsContext {
+    currentProductId?: string;
+    sessionId?: string;
+    visitorId?: string;
+    userId?: string;
+}
+export interface SelwiseReactNativeConfig {
+    siteKey: string;
+    apiKey: string;
+    apiUrl?: string;
+    sdkPlatform?: string;
+    sdkVersion?: string;
+    flushIntervalMs?: number;
+    batchSize?: number;
+    maxRetries?: number;
+    maxQueueSize?: number;
+    journeyTtlMs?: number;
+    storagePrefix?: string;
+    storage?: AsyncStorageLike;
+}
+export interface IdentityState {
+    visitorId: string;
+    sessionId: string;
+    journeyId: string;
+    journeyCreatedAt: number;
+    siteUserId?: string;
+    dataLayer: SelwiseDataLayer[];
+    consentState: ConsentState | null;
+    screenContext: ScreenContext | null;
+}
+export interface QueuedEvent {
+    eventId: string;
+    eventSchemaVersion: number;
+    eventTs: number;
+    timestamp: number;
+    name: string;
+    entityType: string;
+    entityId?: string;
+    metadata?: Record<string, unknown>;
+    retryCount: number;
+    nextAttemptAt: number;
+}
+export interface IdentifyResult {
+    success: boolean;
+    merged?: boolean;
+}
+export interface JourneyState {
+    journeyId: string | null;
+    age: number | null;
+    isValid: boolean;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function sanitizeMetadata(metadata?: Record<string, unknown>): Record<string, unknown> | undefined;
+export declare function stripTrailingSlash(url: string): string;
+export declare function randomId(prefix: string): string;
+export declare function createJourneyId(visitorId: string): string;
+export declare function createEventId(): string;
+export declare function toQueryString(params: Record<string, unknown>): string;
+export declare function delay(ms: number): Promise<void>;

package/dist/utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeMetadata = sanitizeMetadata;
+exports.stripTrailingSlash = stripTrailingSlash;
+exports.randomId = randomId;
+exports.createJourneyId = createJourneyId;
+exports.createEventId = createEventId;
+exports.toQueryString = toQueryString;
+exports.delay = delay;
+const DEPRECATED_METADATA_FIELDS = new Set(['productId', 'productSku', 'sku']);
+function sanitizeMetadata(metadata) {
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        return metadata;
+    }
+    const sanitized = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (DEPRECATED_METADATA_FIELDS.has(key)) {
+            continue;
+        }
+        sanitized[key] = value;
+    }
+    return sanitized;
+}
+function stripTrailingSlash(url) {
+    return url.replace(/\/+$/, '');
+}
+function randomId(prefix) {
+    const cryptoApi = globalThis.crypto;
+    if (cryptoApi && typeof cryptoApi.randomUUID === 'function') {
+        return `${prefix}_${cryptoApi.randomUUID()}`;
+    }
+    const randomChunk = Math.random().toString(36).slice(2);
+    return `${prefix}_${Date.now().toString(36)}${randomChunk}`;
+}
+function createJourneyId(visitorId) {
+    return `journey_${visitorId}_${Date.now()}`;
+}
+function createEventId() {
+    return randomId('evt');
+}
+function toQueryString(params) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        query.append(key, String(value));
+    }
+    const serialized = query.toString();
+    return serialized.length > 0 ? `?${serialized}` : '';
+}
+async function delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@selwise/react-native",
+  "version": "0.1.1",
+  "description": "Selwise headless React Native SDK",
+  "license": "MIT",
+  "private": false,
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "pnpm run clean && tsc -p tsconfig.json",
+    "test": "jest"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": ">=1.0.0",
+    "react-native": ">=0.70.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.10.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.3.3"
+  }
+}