kewa-react-native 1.0.0

package/lib/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KewaAutoTracker = exports.KewaTracker = exports.useKewa = exports.KewaProvider = exports.DeviceInfoCollector = exports.KEWA_CONSTANTS = void 0;
+exports.useAutoTracker = useAutoTracker;
+const KewaProvider_1 = require("./KewaProvider");
+Object.defineProperty(exports, "KewaProvider", { enumerable: true, get: function () { return KewaProvider_1.KewaProvider; } });
+Object.defineProperty(exports, "useKewa", { enumerable: true, get: function () { return KewaProvider_1.useKewa; } });
+__exportStar(require("./types"), exports);
+var constants_1 = require("./utils/constants");
+Object.defineProperty(exports, "KEWA_CONSTANTS", { enumerable: true, get: function () { return constants_1.KEWA_CONSTANTS; } });
+var DeviceInfo_1 = require("./utils/DeviceInfo");
+Object.defineProperty(exports, "DeviceInfoCollector", { enumerable: true, get: function () { return DeviceInfo_1.DeviceInfoCollector; } });
+const Kewa = (0, KewaProvider_1.getDefaultKewaInstance)();
+exports.default = Kewa;
+class KewaTracker {
+    static setupNavigationTracking(navigationRef) {
+        const kewa = (0, KewaProvider_1.getDefaultKewaInstance)();
+        const routeNameRef = { current: '' };
+        return {
+            onReady: () => {
+                var _a;
+                const currentRoute = (_a = navigationRef.current) === null || _a === void 0 ? void 0 : _a.getCurrentRoute();
+                if (currentRoute) {
+                    routeNameRef.current = currentRoute.name;
+                }
+            },
+            onStateChange: async () => {
+                var _a;
+                if (!kewa.isAutoScreenViewTrackingEnabled()) {
+                    return;
+                }
+                const previousRouteName = routeNameRef.current;
+                const currentRoute = (_a = navigationRef.current) === null || _a === void 0 ? void 0 : _a.getCurrentRoute();
+                if (currentRoute && previousRouteName !== currentRoute.name) {
+                    await kewa.trackScreenView(currentRoute.name, {
+                        previousScreen: previousRouteName,
+                        params: currentRoute.params,
+                    });
+                    routeNameRef.current = currentRoute.name;
+                }
+            },
+        };
+    }
+    static trackButtonPress(buttonName, additionalData = {}) {
+        const kewa = (0, KewaProvider_1.getDefaultKewaInstance)();
+        return async () => {
+            await kewa.trackEvent('button_press', {
+                buttonName,
+                ...additionalData,
+            });
+        };
+    }
+    static trackFormSubmission(formName, formData = {}) {
+        const kewa = (0, KewaProvider_1.getDefaultKewaInstance)();
+        return async () => {
+            await kewa.trackEvent('form_submit', {
+                formName,
+                ...formData,
+            });
+        };
+    }
+    static trackError(error, context = {}) {
+        return (0, KewaProvider_1.getDefaultKewaInstance)().trackError(error, context);
+    }
+}
+exports.KewaTracker = KewaTracker;
+exports.KewaAutoTracker = KewaTracker;
+function useAutoTracker() {
+    const kewa = (0, KewaProvider_1.useKewa)();
+    return {
+        setupNavigationTracking: KewaTracker.setupNavigationTracking,
+        trackButtonPress: (buttonName, additionalData = {}) => async () => {
+            await kewa.trackEvent('button_press', { buttonName, ...additionalData });
+        },
+        trackFormSubmission: (formName, formData = {}) => async () => {
+            await kewa.trackEvent('form_submit', { formName, ...formData });
+        },
+        trackError: kewa.trackError.bind(kewa),
+    };
+}

package/lib/types/config.d.ts

@@ -0,0 +1,32 @@
+export interface KewaConfig {
+    appUrl: string;
+    apiKey: string;
+    projectId?: string;
+    disableTracking?: boolean;
+    disableEventTracking?: boolean;
+    disableAppStateTracking?: boolean;
+    disableScreenViewTracking?: boolean;
+    batchSize?: number;
+    maxQueueSize?: number;
+    enableDebugLogging?: boolean;
+    /** @deprecated Use appUrl instead */
+    apiUrl?: string;
+}
+export interface DeviceInfo {
+    appName: string;
+    platform: string;
+    userAgent: string;
+    platformVersion: string | number;
+    appVersion: string;
+    deviceName?: string;
+    buildNumber?: string;
+    deviceModel: string;
+    deviceId?: string;
+    screenWidth: number;
+    screenHeight: number;
+    timezone: string;
+    carrier?: string;
+    isTablet?: boolean;
+    brand?: string;
+    manufacturer?: string;
+}

package/lib/types/config.js

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

package/lib/types/events.d.ts

@@ -0,0 +1,104 @@
+import { DeviceInfo } from "./config";
+export interface BaseEventData {
+    timestamp?: string;
+    screenName?: string;
+    previousScreen?: string;
+    [key: string]: any;
+}
+export interface KewaEvent {
+    eventName: string;
+    eventData: BaseEventData;
+    contactData?: ContactData;
+    deviceId?: string | null;
+    deviceInfo?: DeviceInfo;
+    metadata?: EventMetadata;
+    timestamp: string;
+}
+export interface ContactData {
+    id?: string;
+    title?: string;
+    firstname?: string;
+    lastname?: string;
+    company?: string;
+    position?: string;
+    email?: string;
+    mobile?: string;
+    phone?: string;
+    points?: number;
+    fax?: string;
+    address1?: string;
+    address2?: string;
+    city?: string;
+    state?: string;
+    zipcode?: string;
+    country?: string;
+    preferred_locale?: string;
+    timezone?: string;
+    last_active?: string;
+    attribution_date?: string;
+    attribution?: number;
+    website?: string;
+    facebook?: string;
+    foursquare?: string;
+    instagram?: string;
+    linkedin?: string;
+    skype?: string;
+    twitter?: string;
+    companyaddress1?: string;
+    companyaddress2?: string;
+    companyemail?: string;
+    companyphone?: string;
+    companycity?: string;
+    companystate?: string;
+    companyzipcode?: string;
+    companycountry?: string;
+    companyname?: string;
+    companywebsite?: string;
+    companynumber_of_employees?: number;
+    companyfax?: string;
+    companyannual_revenue?: number;
+    companyindustry?: string;
+    companydescription?: string;
+    [key: string]: any;
+}
+export interface EventMetadata {
+    eventId: string;
+    attemptCount?: number;
+    queuedAt?: string;
+    sentAt?: string;
+}
+export interface AppLaunchEvent extends BaseEventData {
+    isFirstLaunch: boolean;
+    installSource?: string;
+    referrer?: string;
+    campaignId?: string;
+}
+export interface UserLoginEvent extends BaseEventData {
+    userId: string;
+    email?: string;
+    loginMethod: 'email' | 'google' | 'facebook' | 'apple' | 'phone' | 'custom';
+}
+export interface UserRegistrationEvent extends BaseEventData {
+    userId: string;
+    email?: string;
+    registrationMethod: 'email' | 'google' | 'facebook' | 'apple' | 'phone';
+}
+export interface ScreenViewEvent extends BaseEventData {
+    screenName: string;
+    screenClass?: string;
+    loadTime?: number;
+}
+export interface ErrorEvent extends BaseEventData {
+    errorMessage: string;
+    errorStack?: string;
+    errorName: string;
+    isFatal?: boolean;
+    context?: Record<string, any>;
+}
+export interface AppForegroundEvent extends BaseEventData {
+    timestamp: string;
+}
+export interface AppBackgroundEvent extends BaseEventData {
+    timestamp: string;
+}
+export type PredefinedEvents = AppLaunchEvent | UserLoginEvent | UserRegistrationEvent | ScreenViewEvent | ErrorEvent;

package/lib/types/events.js

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

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './events';
+export * from './response';

package/lib/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./response"), exports);

package/lib/types/response.d.ts

@@ -0,0 +1,15 @@
+export interface KewaResponse {
+    success: boolean;
+    id?: string;
+    sid?: string;
+    device_id?: string;
+    message?: string;
+}
+export interface KewaBatchResponse {
+    success: boolean;
+    user_id?: string;
+    processed_count: number;
+    failed_count: number;
+    errors?: string[];
+    timestamp?: string;
+}

package/lib/types/response.js

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

package/lib/utils/DeviceInfo.d.ts

@@ -0,0 +1,4 @@
+import { DeviceInfo as DeviceInfoType } from '../types';
+export declare class DeviceInfoCollector {
+    static collect(): Promise<DeviceInfoType>;
+}

package/lib/utils/DeviceInfo.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceInfoCollector = void 0;
+const react_native_1 = require("react-native");
+const react_native_device_info_1 = __importDefault(require("react-native-device-info"));
+class DeviceInfoCollector {
+    static async collect() {
+        const { width, height } = react_native_1.Dimensions.get('window');
+        const deviceInfo = {
+            appName: react_native_device_info_1.default.getApplicationName(),
+            platform: react_native_1.Platform.OS,
+            platformVersion: react_native_1.Platform.Version,
+            userAgent: await react_native_device_info_1.default.getUserAgent(),
+            appVersion: react_native_device_info_1.default.getReadableVersion(),
+            buildNumber: react_native_device_info_1.default.getBuildNumber(),
+            deviceName: await react_native_device_info_1.default.getDeviceName(),
+            deviceModel: react_native_device_info_1.default.getModel(),
+            screenWidth: width,
+            screenHeight: height,
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            carrier: await react_native_device_info_1.default.getCarrier(),
+            brand: react_native_device_info_1.default.getBrand(),
+            manufacturer: await react_native_device_info_1.default.getManufacturer(),
+            isTablet: react_native_device_info_1.default.isTablet(),
+        };
+        return deviceInfo;
+    }
+}
+exports.DeviceInfoCollector = DeviceInfoCollector;

package/lib/utils/NetworkManager.d.ts

@@ -0,0 +1,17 @@
+import { ContactData, KewaEvent, KewaResponse } from '../types';
+export declare class NetworkManager {
+    private appUrl;
+    private apiKey;
+    private projectId;
+    private isOnline;
+    private unsubscribe;
+    constructor(appUrl: string, apiKey: string, projectId: string);
+    private getTrackUrl;
+    private getContactUrl;
+    private setupNetworkMonitoring;
+    sendEvent(event: KewaEvent): Promise<KewaResponse>;
+    updateContact(contact: ContactData): Promise<KewaResponse>;
+    private post;
+    getNetworkStatus(): boolean;
+    cleanup(): void;
+}

package/lib/utils/NetworkManager.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkManager = void 0;
+const netinfo_1 = __importDefault(require("@react-native-community/netinfo"));
+const StorageManager_1 = require("./StorageManager");
+class NetworkManager {
+    constructor(appUrl, apiKey, projectId) {
+        this.appUrl = '';
+        this.apiKey = '';
+        this.projectId = '';
+        this.isOnline = true;
+        this.unsubscribe = null;
+        this.appUrl = appUrl.replace(/\/$/, '');
+        this.apiKey = apiKey;
+        this.projectId = projectId;
+        this.setupNetworkMonitoring();
+    }
+    getTrackUrl() {
+        return `${this.appUrl}/t/${this.projectId}/mtc/event/track`;
+    }
+    getContactUrl() {
+        return `${this.appUrl}/t/${this.projectId}/mtc`;
+    }
+    setupNetworkMonitoring() {
+        this.unsubscribe = netinfo_1.default.addEventListener(state => {
+            var _a;
+            this.isOnline = (_a = state.isConnected) !== null && _a !== void 0 ? _a : true;
+        });
+    }
+    async sendEvent(event) {
+        const eventPayload = {
+            event: event.eventName,
+            timestamp: event.timestamp,
+            data: event.eventData,
+            contact: event.contactData,
+            kewa_device_id: event.deviceId,
+            device: event.deviceInfo,
+        };
+        return this.post(this.getTrackUrl(), eventPayload);
+    }
+    async updateContact(contact) {
+        const ktcId = await StorageManager_1.StorageManager.getKtcId();
+        const deviceId = await StorageManager_1.StorageManager.getDeviceId();
+        return this.post(this.getContactUrl(), { contact, mtc_id: ktcId, kewa_device_id: deviceId });
+    }
+    async post(url, body) {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'secret': `${this.apiKey}`,
+                'User-Agent': 'Kewa-SDK/1.0.0',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`Kewa Analytics SDK: HTTP error! status: ${response.status}`);
+        }
+        const responseData = await response.json();
+        if (!responseData.success) {
+            throw new Error('Kewa Analytics SDK: Responded with an error ' + responseData.message);
+        }
+        return responseData;
+    }
+    getNetworkStatus() {
+        return this.isOnline;
+    }
+    cleanup() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+        }
+    }
+}
+exports.NetworkManager = NetworkManager;

package/lib/utils/StorageManager.d.ts

@@ -0,0 +1,16 @@
+import { ContactData, KewaEvent } from '../types';
+export declare class StorageManager {
+    static getKtcId(): Promise<string | null>;
+    static setKtcId(ktcId: string): Promise<void>;
+    static removeKtcId(): Promise<void>;
+    static getDeviceId(): Promise<string | null>;
+    static setDeviceId(deviceId: string): Promise<void>;
+    static removeDeviceId(): Promise<void>;
+    static getUserProperties(): Promise<ContactData>;
+    static setUserProperties(properties: ContactData): Promise<void>;
+    static removeUserProperties(): Promise<void>;
+    static getQueuedEvents(): Promise<KewaEvent[]>;
+    static setQueuedEvents(events: KewaEvent[]): Promise<void>;
+    static addQueuedEvent(event: KewaEvent): Promise<void>;
+    static clearQueuedEvents(): Promise<void>;
+}

package/lib/utils/StorageManager.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageManager = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const constants_1 = require("../utils/constants");
+class StorageManager {
+    static async getKtcId() {
+        try {
+            return await async_storage_1.default.getItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.KTC_ID);
+        }
+        catch (error) {
+            console.error('Failed to get ktc_id:', error);
+            return null;
+        }
+    }
+    static async setKtcId(ktcId) {
+        try {
+            await async_storage_1.default.setItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.KTC_ID, ktcId);
+        }
+        catch (error) {
+            console.error('Failed to set ktc_id:', error);
+        }
+    }
+    static async removeKtcId() {
+        try {
+            await async_storage_1.default.removeItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.KTC_ID);
+        }
+        catch (error) {
+            console.error('Failed to remove ktc_id:', error);
+        }
+    }
+    static async getDeviceId() {
+        try {
+            return await async_storage_1.default.getItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.DEVICE_ID);
+        }
+        catch (error) {
+            console.error('Failed to get device_id:', error);
+            return null;
+        }
+    }
+    static async setDeviceId(deviceId) {
+        try {
+            await async_storage_1.default.setItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.DEVICE_ID, deviceId);
+        }
+        catch (error) {
+            console.error('Failed to set device_id:', error);
+        }
+    }
+    static async removeDeviceId() {
+        try {
+            await async_storage_1.default.removeItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.DEVICE_ID);
+        }
+        catch (error) {
+            console.error('Failed to remove device_id:', error);
+        }
+    }
+    static async getUserProperties() {
+        try {
+            const props = await async_storage_1.default.getItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.USER_PROPERTIES);
+            return props ? JSON.parse(props) : {};
+        }
+        catch (error) {
+            console.error('Kewa Analytics SDK: Failed to get user properties:', error);
+            return {};
+        }
+    }
+    static async setUserProperties(properties) {
+        try {
+            await async_storage_1.default.setItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.USER_PROPERTIES, JSON.stringify(properties));
+        }
+        catch (error) {
+            console.error('Kewa Analytics SDK: Failed to set user properties:', error);
+        }
+    }
+    static async removeUserProperties() {
+        try {
+            await async_storage_1.default.removeItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.USER_PROPERTIES);
+        }
+        catch (error) {
+            console.error('Kewa Analytics SDK: Failed to remove user properties:', error);
+        }
+    }
+    static async getQueuedEvents() {
+        try {
+            const events = await async_storage_1.default.getItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.QUEUED_EVENTS);
+            return events ? JSON.parse(events) : [];
+        }
+        catch (error) {
+            console.error('Kewa Analytics SDK: Failed to get queued events:', error);
+            return [];
+        }
+    }
+    static async setQueuedEvents(events) {
+        try {
+            // Limit queue size
+            const limitedEvents = events.slice(-constants_1.KEWA_CONSTANTS.DEFAULTS.MAX_QUEUE_SIZE);
+            await async_storage_1.default.setItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.QUEUED_EVENTS, JSON.stringify(limitedEvents));
+        }
+        catch (error) {
+            console.error('Kewa Analytics SDK: Failed to set queued events:', error);
+        }
+    }
+    static async addQueuedEvent(event) {
+        const events = await this.getQueuedEvents();
+        events.push(event);
+        await this.setQueuedEvents(events);
+    }
+    static async clearQueuedEvents() {
+        try {
+            await async_storage_1.default.removeItem(constants_1.KEWA_CONSTANTS.STORAGE_KEYS.QUEUED_EVENTS);
+        }
+        catch (error) {
+            console.error('Kewa Analytics SDK: Failed to clear queued events:', error);
+        }
+    }
+}
+exports.StorageManager = StorageManager;

package/lib/utils/constants.d.ts

@@ -0,0 +1,26 @@
+export declare const KEWA_CONSTANTS: {
+    readonly STORAGE_KEYS: {
+        readonly KTC_ID: "kewa_ktc_id";
+        readonly DEVICE_ID: "kewa_device_id";
+        readonly QUEUED_EVENTS: "kewa_queued_events";
+        readonly USER_PROPERTIES: "kewa_user_properties";
+    };
+    readonly EVENTS: {
+        readonly APP_LAUNCH: "app_launch";
+        readonly APP_FOREGROUND: "app_foreground";
+        readonly APP_BACKGROUND: "app_background";
+        readonly USER_LOGIN: "user_login";
+        readonly USER_LOGOUT: "user_logout";
+        readonly USER_REGISTRATION: "user_registration";
+        readonly SCREEN_VIEW: "screen_view";
+        readonly ERROR: "error";
+        readonly BUTTON_PRESS: "button_press";
+        readonly FORM_SUBMIT: "form_submit";
+    };
+    readonly DEFAULTS: {
+        readonly BATCH_SIZE: 10;
+        readonly MAX_QUEUE_SIZE: 100;
+        readonly RETRY_ATTEMPTS: 3;
+        readonly RETRY_DELAY_MS: 1000;
+    };
+};

package/lib/utils/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEWA_CONSTANTS = void 0;
+exports.KEWA_CONSTANTS = {
+    STORAGE_KEYS: {
+        KTC_ID: 'kewa_ktc_id',
+        DEVICE_ID: 'kewa_device_id',
+        QUEUED_EVENTS: 'kewa_queued_events',
+        USER_PROPERTIES: 'kewa_user_properties',
+    },
+    EVENTS: {
+        APP_LAUNCH: 'app_launch',
+        APP_FOREGROUND: 'app_foreground',
+        APP_BACKGROUND: 'app_background',
+        USER_LOGIN: 'user_login',
+        USER_LOGOUT: 'user_logout',
+        USER_REGISTRATION: 'user_registration',
+        SCREEN_VIEW: 'screen_view',
+        ERROR: 'error',
+        BUTTON_PRESS: 'button_press',
+        FORM_SUBMIT: 'form_submit',
+    },
+    DEFAULTS: {
+        BATCH_SIZE: 10,
+        MAX_QUEUE_SIZE: 100,
+        RETRY_ATTEMPTS: 3,
+        RETRY_DELAY_MS: 1000,
+    },
+};

package/lib/utils/debug.d.ts

@@ -0,0 +1,3 @@
+export declare function setDebugLogging(enabled: boolean): void;
+export declare function isDebugLoggingEnabled(): boolean;
+export declare function kewaDebug(...args: unknown[]): void;

package/lib/utils/debug.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDebugLogging = setDebugLogging;
+exports.isDebugLoggingEnabled = isDebugLoggingEnabled;
+exports.kewaDebug = kewaDebug;
+let debugEnabled = false;
+function setDebugLogging(enabled) {
+    debugEnabled = enabled;
+}
+function isDebugLoggingEnabled() {
+    return debugEnabled;
+}
+function kewaDebug(...args) {
+    if (debugEnabled) {
+        console.log('[Kewa]', ...args);
+    }
+}