wolves-js-client 1.0.0

package/dist/EventLogger.d.ts

@@ -0,0 +1,13 @@
+import { Network } from './Network';
+import { WolvesEvent } from './Types';
+export declare class EventLogger {
+    private queue;
+    private flushIntervalId;
+    private network;
+    private maxQueueSize;
+    constructor(network: Network);
+    enqueue(event: WolvesEvent): void;
+    flush(): Promise<void>;
+    private start;
+    stop(): void;
+}

package/dist/EventLogger.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLogger = void 0;
+const Log_1 = require("./Log");
+const DEFAULT_QUEUE_SIZE = 100;
+const DEFAULT_FLUSH_INTERVAL_MS = 10000;
+class EventLogger {
+    constructor(network) {
+        this.queue = [];
+        this.flushIntervalId = null;
+        this.maxQueueSize = DEFAULT_QUEUE_SIZE;
+        this.network = network;
+        this.start();
+    }
+    enqueue(event) {
+        this.queue.push(event);
+        if (this.queue.length >= this.maxQueueSize) {
+            this.flush();
+        }
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.queue.length === 0) {
+                return;
+            }
+            const events = [...this.queue];
+            this.queue = [];
+            try {
+                yield this.network.sendEvents(events);
+            }
+            catch (e) {
+                Log_1.Log.error('Failed to flush events', e);
+                // Add failed events back to the front of the queue
+                this.queue = [...events, ...this.queue];
+                // Respect maxQueueSize to avoid memory issues
+                if (this.queue.length > this.maxQueueSize) {
+                    this.queue = this.queue.slice(this.queue.length - this.maxQueueSize);
+                }
+            }
+        });
+    }
+    start() {
+        if (this.flushIntervalId) {
+            return;
+        }
+        this.flushIntervalId = setInterval(() => {
+            this.flush();
+        }, DEFAULT_FLUSH_INTERVAL_MS);
+    }
+    stop() {
+        if (this.flushIntervalId) {
+            clearInterval(this.flushIntervalId);
+            this.flushIntervalId = null;
+        }
+        this.flush();
+    }
+}
+exports.EventLogger = EventLogger;

package/dist/Experiment.d.ts

@@ -0,0 +1,11 @@
+export declare class Experiment {
+    private name;
+    private value;
+    private ruleID;
+    private group;
+    constructor(name: string, value: Record<string, any>, ruleID: string, group: string);
+    get<T>(key: string, defaultValue: T): T;
+    getRuleID(): string;
+    getGroupName(): string;
+    getValue(): Record<string, any>;
+}

package/dist/Experiment.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Experiment = void 0;
+class Experiment {
+    constructor(name, value, ruleID, group) {
+        this.name = name;
+        this.value = value;
+        this.ruleID = ruleID;
+        this.group = group;
+    }
+    get(key, defaultValue) {
+        if (this.value && key in this.value) {
+            return this.value[key];
+        }
+        return defaultValue;
+    }
+    getRuleID() {
+        return this.ruleID;
+    }
+    getGroupName() {
+        return this.group;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+exports.Experiment = Experiment;

package/dist/Log.d.ts

@@ -0,0 +1,15 @@
+export declare const LogLevel: {
+    readonly None: 0;
+    readonly Error: 1;
+    readonly Warn: 2;
+    readonly Info: 3;
+    readonly Debug: 4;
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export declare abstract class Log {
+    static level: LogLevel;
+    static info(...args: unknown[]): void;
+    static debug(...args: unknown[]): void;
+    static warn(...args: unknown[]): void;
+    static error(...args: unknown[]): void;
+}

package/dist/Log.js

@@ -0,0 +1,43 @@
+"use strict";
+/* eslint-disable no-console */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.LogLevel = void 0;
+exports.LogLevel = {
+    None: 0,
+    Error: 1,
+    Warn: 2,
+    Info: 3,
+    Debug: 4,
+};
+const DEBUG = ' DEBUG ';
+const _INFO = '  INFO ';
+const _WARN = '  WARN ';
+const ERROR = ' ERROR ';
+function addTag(args) {
+    args.unshift('[Wolves]');
+    return args;
+}
+class Log {
+    static info(...args) {
+        if (Log.level >= exports.LogLevel.Info) {
+            console.info(_INFO, ...addTag(args));
+        }
+    }
+    static debug(...args) {
+        if (Log.level >= exports.LogLevel.Debug) {
+            console.debug(DEBUG, ...addTag(args));
+        }
+    }
+    static warn(...args) {
+        if (Log.level >= exports.LogLevel.Warn) {
+            console.warn(_WARN, ...addTag(args));
+        }
+    }
+    static error(...args) {
+        if (Log.level >= exports.LogLevel.Error) {
+            console.error(ERROR, ...addTag(args));
+        }
+    }
+}
+exports.Log = Log;
+Log.level = exports.LogLevel.Warn;

package/dist/Network.d.ts

@@ -0,0 +1,8 @@
+import { WolvesUser } from './WolvesUser';
+export declare class Network {
+    private sdkKey;
+    private api;
+    constructor(sdkKey: string, api?: string);
+    fetchConfig(user: WolvesUser, sinceTime?: number, retries?: number, backoff?: number): Promise<any>;
+    sendEvents(events: any[], retries?: number, backoff?: number): Promise<void>;
+}

package/dist/Network.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Network = void 0;
+const Log_1 = require("./Log");
+const RETRYABLE_CODES = [408, 500, 502, 503, 504, 522, 524, 599];
+class Network {
+    constructor(sdkKey, api = 'https://wolves-nova-dev.azurewebsites.net/api') {
+        this.sdkKey = sdkKey;
+        this.api = api;
+    }
+    fetchConfig(user_1, sinceTime_1) {
+        return __awaiter(this, arguments, void 0, function* (user, sinceTime, retries = 2, backoff = 1000) {
+            try {
+                const body = { user };
+                if (sinceTime) {
+                    body.sinceTime = sinceTime;
+                }
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
+                const response = yield fetch(`${this.api}/events/initialize`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'wolves-api-key': this.sdkKey,
+                    },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                }).finally(() => clearTimeout(timeoutId));
+                if (!response.ok) {
+                    const status = response.status;
+                    if (RETRYABLE_CODES.includes(status) && retries > 0) {
+                        yield new Promise(resolve => setTimeout(resolve, backoff));
+                        return this.fetchConfig(user, sinceTime, retries - 1, backoff * 2);
+                    }
+                    throw new Error(`Failed to fetch config: ${response.status} ${response.statusText}`);
+                }
+                return yield response.json();
+            }
+            catch (e) {
+                if (retries > 0) {
+                    yield new Promise(resolve => setTimeout(resolve, backoff));
+                    return this.fetchConfig(user, sinceTime, retries - 1, backoff * 2);
+                }
+                Log_1.Log.error('Failed to fetch config', e);
+                return null;
+            }
+        });
+    }
+    sendEvents(events_1) {
+        return __awaiter(this, arguments, void 0, function* (events, retries = 3, backoff = 1000) {
+            const apiEvents = events.map(e => {
+                var _a, _b;
+                return ({
+                    timestamp: new Date(e.time).toISOString(),
+                    event: e.eventName,
+                    user_id: (_b = (_a = e.user) === null || _a === void 0 ? void 0 : _a.userID) !== null && _b !== void 0 ? _b : '',
+                    user_properties: e.user,
+                    value: e.value,
+                    metadata: e.metadata
+                });
+            });
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 10000); // 10s timeout
+                const response = yield fetch(`${this.api}/events/ingest/batch`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'wolves-api-key': this.sdkKey,
+                    },
+                    body: JSON.stringify({ events: apiEvents }),
+                    signal: controller.signal,
+                }).finally(() => clearTimeout(timeoutId));
+                if (!response.ok) {
+                    const status = response.status;
+                    if (RETRYABLE_CODES.includes(status) && retries > 0) {
+                        yield new Promise(resolve => setTimeout(resolve, backoff));
+                        return this.sendEvents(events, retries - 1, backoff * 2);
+                    }
+                    throw new Error(`Failed to log events: ${response.status} ${response.statusText}`);
+                }
+            }
+            catch (e) {
+                if (retries > 0) {
+                    yield new Promise(resolve => setTimeout(resolve, backoff));
+                    return this.sendEvents(events, retries - 1, backoff * 2);
+                }
+                throw e;
+            }
+        });
+    }
+}
+exports.Network = Network;

package/dist/StatsigClient.d.ts

@@ -0,0 +1,15 @@
+import { StatsigUser } from './StatsigUser';
+import { Experiment, StatsigUpdateDetails } from './Types';
+export declare class StatsigClient {
+    private sdkKey;
+    private user;
+    private network;
+    private store;
+    private initialized;
+    constructor(sdkKey: string, user: StatsigUser);
+    initializeAsync(): Promise<StatsigUpdateDetails>;
+    initializeSync(): StatsigUpdateDetails;
+    getExperiment(experimentName: string): Experiment;
+    logEvent(eventName: string, value?: string | number, metadata?: Record<string, string>): void;
+    private logExposure;
+}

package/dist/StatsigClient.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsigClient = void 0;
+const Network_1 = require("./Network");
+const Store_1 = require("./Store");
+class StatsigClient {
+    constructor(sdkKey, user) {
+        this.initialized = false;
+        this.sdkKey = sdkKey;
+        this.user = user;
+        this.network = new Network_1.Network(sdkKey);
+        this.store = new Store_1.Store();
+    }
+    initializeAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = yield this.network.fetchConfig(this.user);
+            if (config) {
+                this.store.setValues(config);
+                this.initialized = true;
+                return { success: true };
+            }
+            return { success: false, errorMessage: 'Failed to fetch config' };
+        });
+    }
+    initializeSync() {
+        // In a real implementation, this might load from local storage or cache.
+        // For this minimal implementation, we trigger a background fetch.
+        this.network.fetchConfig(this.user).then((config) => {
+            if (config) {
+                this.store.setValues(config);
+            }
+        });
+        this.initialized = true;
+        return { success: true };
+    }
+    getExperiment(experimentName) {
+        var _a, _b, _c;
+        const config = this.store.getExperiment(experimentName);
+        const experiment = {
+            name: experimentName,
+            value: (_a = config === null || config === void 0 ? void 0 : config.value) !== null && _a !== void 0 ? _a : {},
+            ruleID: (_b = config === null || config === void 0 ? void 0 : config.rule_id) !== null && _b !== void 0 ? _b : '',
+            groupName: (_c = config === null || config === void 0 ? void 0 : config.group) !== null && _c !== void 0 ? _c : null,
+            get: (key, defaultValue) => {
+                var _a;
+                const val = (_a = config === null || config === void 0 ? void 0 : config.value) === null || _a === void 0 ? void 0 : _a[key];
+                if (val === undefined || val === null) {
+                    return defaultValue;
+                }
+                return val;
+            }
+        };
+        // Log exposure
+        this.logExposure(experimentName, config);
+        return experiment;
+    }
+    logEvent(eventName, value, metadata) {
+        const event = {
+            eventName,
+            value,
+            metadata,
+            user: this.user,
+            time: Date.now(),
+        };
+        this.network.sendEvents([event]);
+    }
+    logExposure(experimentName, experiment) {
+        var _a, _b, _c;
+        const exposureEvent = {
+            eventName: 'statsig::exposure',
+            user: this.user,
+            time: Date.now(),
+            metadata: {
+                config: experimentName,
+                ruleID: (_a = experiment === null || experiment === void 0 ? void 0 : experiment.rule_id) !== null && _a !== void 0 ? _a : '',
+                group: (_b = experiment === null || experiment === void 0 ? void 0 : experiment.group) !== null && _b !== void 0 ? _b : '',
+                value: JSON.stringify((_c = experiment === null || experiment === void 0 ? void 0 : experiment.value) !== null && _c !== void 0 ? _c : {}),
+            },
+        };
+        this.network.sendEvents([exposureEvent]);
+    }
+}
+exports.StatsigClient = StatsigClient;

package/dist/StatsigUser.d.ts

@@ -0,0 +1,6 @@
+export type StatsigUser = {
+    userID?: string;
+    email?: string;
+    ip?: string;
+    custom?: Record<string, string | number | boolean | Array<string>>;
+};

package/dist/StatsigUser.js

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

package/dist/Store.d.ts

@@ -0,0 +1,18 @@
+export type ExperimentConfig = {
+    value: Record<string, any>;
+    experiment_id?: string;
+    group?: string;
+};
+export type InitializeResponse = {
+    dynamic_configs: Record<string, ExperimentConfig>;
+    has_updates: boolean;
+    time: number;
+};
+export declare class Store {
+    private values;
+    constructor();
+    setValues(values: InitializeResponse): void;
+    getExperiment(name: string): ExperimentConfig | null;
+    getValues(): InitializeResponse | null;
+    getLastUpdateTime(): number | undefined;
+}

package/dist/Store.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = void 0;
+class Store {
+    constructor() {
+        this.values = null;
+    }
+    setValues(values) {
+        this.values = values;
+    }
+    getExperiment(name) {
+        if (!this.values || !this.values.dynamic_configs) {
+            return null;
+        }
+        return this.values.dynamic_configs[name] || null;
+    }
+    getValues() {
+        return this.values;
+    }
+    getLastUpdateTime() {
+        var _a;
+        return (_a = this.values) === null || _a === void 0 ? void 0 : _a.time;
+    }
+}
+exports.Store = Store;

package/dist/Types.d.ts

@@ -0,0 +1,25 @@
+import { WolvesUser } from './WolvesUser';
+export type WolvesUpdateDetails = {
+    success: boolean;
+    errorMessage?: string;
+};
+export type WolvesEvent = {
+    eventName: string;
+    value?: string | number;
+    metadata?: Record<string, string>;
+    user?: WolvesUser;
+    time?: number;
+};
+export type ExperimentConfig = {
+    name: string;
+    value: Record<string, unknown>;
+    experiment_id?: string;
+    group?: string;
+};
+export type Experiment = {
+    name: string;
+    value: Record<string, unknown>;
+    experimentID: string;
+    groupName: string | null;
+    get: <T>(key: string, defaultValue: T) => T;
+};

package/dist/Types.js

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

package/dist/WolvesClient.d.ts

@@ -0,0 +1,25 @@
+import { WolvesUser } from './WolvesUser';
+import { Experiment, WolvesUpdateDetails } from './Types';
+export declare class WolvesClient {
+    private sdkKey;
+    private user;
+    private network;
+    private store;
+    private logger;
+    private initialized;
+    constructor(sdkKey: string, user: WolvesUser);
+    initializeAsync(): Promise<WolvesUpdateDetails>;
+    initializeSync(): WolvesUpdateDetails;
+    updateUserAsync(user: WolvesUser): Promise<WolvesUpdateDetails>;
+    updateUserSync(user: WolvesUser): WolvesUpdateDetails;
+    getExperiment(experimentName: string): Experiment;
+    /**
+     * Test-only method to manually trigger an exposure event with a specified group.
+     * This is useful for testing exposure logging without actual experiment assignment.
+     * The experiment ID is retrieved from the store config.
+     */
+    getExperimentForTest(experimentName: string, groupName: string): Experiment;
+    logEvent(eventName: string, value?: string | number, metadata?: Record<string, string>): void;
+    shutdown(): void;
+    private logExposure;
+}

package/dist/WolvesClient.js

@@ -0,0 +1,143 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WolvesClient = void 0;
+const Network_1 = require("./Network");
+const Store_1 = require("./Store");
+const EventLogger_1 = require("./EventLogger");
+class WolvesClient {
+    constructor(sdkKey, user) {
+        this.initialized = false;
+        this.sdkKey = sdkKey;
+        this.user = user;
+        this.network = new Network_1.Network(sdkKey);
+        this.store = new Store_1.Store();
+        this.logger = new EventLogger_1.EventLogger(this.network);
+    }
+    initializeAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = yield this.network.fetchConfig(this.user, this.store.getLastUpdateTime());
+            if (config) {
+                this.store.setValues(config);
+                this.initialized = true;
+                return { success: true };
+            }
+            return { success: false, errorMessage: 'Failed to fetch config' };
+        });
+    }
+    initializeSync() {
+        // In a real implementation, this might load from local storage or cache.
+        // For this minimal implementation, we trigger a background fetch.
+        this.network.fetchConfig(this.user, this.store.getLastUpdateTime()).then((config) => {
+            if (config) {
+                this.store.setValues(config);
+            }
+        });
+        this.initialized = true;
+        return { success: true };
+    }
+    updateUserAsync(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.user = user;
+            this.store = new Store_1.Store(); // Reset store for new user
+            const config = yield this.network.fetchConfig(this.user);
+            if (config) {
+                this.store.setValues(config);
+                return { success: true };
+            }
+            return { success: false, errorMessage: 'Failed to fetch config' };
+        });
+    }
+    updateUserSync(user) {
+        this.user = user;
+        this.store = new Store_1.Store(); // Reset store for new user
+        // In a real implementation, this might load from local storage or cache.
+        // For this minimal implementation, we trigger a background fetch.
+        this.network.fetchConfig(this.user).then((config) => {
+            if (config) {
+                this.store.setValues(config);
+            }
+        });
+        return { success: true };
+    }
+    getExperiment(experimentName) {
+        var _a, _b, _c;
+        const config = this.store.getExperiment(experimentName);
+        const experiment = {
+            name: experimentName,
+            value: (_a = config === null || config === void 0 ? void 0 : config.value) !== null && _a !== void 0 ? _a : {},
+            experimentID: (_b = config === null || config === void 0 ? void 0 : config.experiment_id) !== null && _b !== void 0 ? _b : '',
+            groupName: (_c = config === null || config === void 0 ? void 0 : config.group) !== null && _c !== void 0 ? _c : null,
+            get: (key, defaultValue) => {
+                var _a;
+                const val = (_a = config === null || config === void 0 ? void 0 : config.value) === null || _a === void 0 ? void 0 : _a[key];
+                if (val === undefined || val === null) {
+                    return defaultValue;
+                }
+                return val;
+            }
+        };
+        // Log exposure
+        this.logExposure(experimentName, config);
+        return experiment;
+    }
+    /**
+     * Test-only method to manually trigger an exposure event with a specified group.
+     * This is useful for testing exposure logging without actual experiment assignment.
+     * The experiment ID is retrieved from the store config.
+     */
+    getExperimentForTest(experimentName, groupName) {
+        var _a;
+        const config = this.store.getExperiment(experimentName);
+        const experimentId = (_a = config === null || config === void 0 ? void 0 : config.experiment_id) !== null && _a !== void 0 ? _a : '';
+        const experiment = {
+            name: experimentName,
+            value: {},
+            experimentID: experimentId,
+            groupName: groupName,
+            get: (_key, defaultValue) => {
+                return defaultValue;
+            }
+        };
+        // Log exposure with the specified group and experiment ID from store
+        this.logExposure(experimentName, { group: groupName, experiment_id: experimentId, value: {} });
+        return experiment;
+    }
+    logEvent(eventName, value, metadata) {
+        const event = {
+            eventName,
+            value,
+            metadata,
+            user: this.user,
+            time: Date.now(),
+        };
+        this.logger.enqueue(event);
+    }
+    shutdown() {
+        this.logger.stop();
+    }
+    logExposure(experimentName, experiment) {
+        var _a, _b, _c;
+        const exposureEvent = {
+            eventName: 'exposure',
+            user: this.user,
+            time: Date.now(),
+            metadata: {
+                experimentName: experimentName,
+                experimentID: (_a = experiment === null || experiment === void 0 ? void 0 : experiment.experiment_id) !== null && _a !== void 0 ? _a : '',
+                group: (_b = experiment === null || experiment === void 0 ? void 0 : experiment.group) !== null && _b !== void 0 ? _b : '',
+                value: JSON.stringify((_c = experiment === null || experiment === void 0 ? void 0 : experiment.value) !== null && _c !== void 0 ? _c : {}),
+            },
+        };
+        this.logger.enqueue(exposureEvent);
+    }
+}
+exports.WolvesClient = WolvesClient;

package/dist/WolvesUser.d.ts

@@ -0,0 +1,6 @@
+export type WolvesUser = {
+    userID?: string;
+    email?: string;
+    ip?: string;
+    custom?: Record<string, string | number | boolean | Array<string>>;
+};

package/dist/WolvesUser.js

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { WolvesClient } from './WolvesClient';
+export { WolvesUser } from './WolvesUser';
+export { Experiment } from './Types';
+export { Log, LogLevel } from './Log';

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = exports.Log = exports.WolvesClient = void 0;
+var WolvesClient_1 = require("./WolvesClient");
+Object.defineProperty(exports, "WolvesClient", { enumerable: true, get: function () { return WolvesClient_1.WolvesClient; } });
+var Log_1 = require("./Log");
+Object.defineProperty(exports, "Log", { enumerable: true, get: function () { return Log_1.Log; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return Log_1.LogLevel; } });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "wolves-js-client",
+  "version": "1.0.0",
+  "description": "A Wolves JavaScript Client SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "wolves",
+    "ab-testing",
+    "experiment",
+    "sdk"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "@types/jest": "^29.0.0"
+  }
+}