@rolloutctrl/js-sdk 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,130 @@
+import { FeatureFlagEnvironment, Action, EvaluationContext, EvaluationResult } from '@rolloutctrl/evaluator';
+
+interface FlagConfig extends FeatureFlagEnvironment {
+    key: string;
+}
+interface Configuration {
+    projectId: string;
+    environmentId: string;
+    version: number;
+    flags: FlagConfig[];
+    actions: Action[];
+}
+type VariantResult = EvaluationResult['variant'];
+interface Evaluator {
+    isEnabled(flagKey: string, context?: EvaluationContext): boolean;
+    evaluate(flagKey: string, context?: EvaluationContext): EvaluationResult;
+    getVariant(flagKey: string, context?: EvaluationContext): VariantResult;
+    can(actionKey: string, context?: EvaluationContext): boolean;
+}
+interface StorageAdapter {
+    get(): Promise<Configuration | null>;
+    set(configuration: Configuration): Promise<void>;
+    clear(): Promise<void>;
+}
+interface RolloutCtrlOptions {
+    sdkKey: string;
+    apiUrl?: string;
+    refreshInterval?: number;
+    requestTimeout?: number;
+    bootstrap?: Configuration;
+    storage?: StorageAdapter;
+}
+
+type ClientEventMap = {
+    ready: [];
+    updated: [configuration: Configuration];
+    error: [error: Error];
+    shutdown: [];
+};
+declare class RolloutCtrlClient {
+    private readonly emitter;
+    private readonly repository;
+    private readonly evaluatorManager;
+    private readonly updateProvider;
+    private readonly subscribers;
+    private isInitialized;
+    private readonly readyPromise;
+    private resolveReady;
+    private rejectReady;
+    constructor(options: RolloutCtrlOptions);
+    private initialize;
+    on<K extends keyof ClientEventMap>(event: K, listener: (...args: ClientEventMap[K]) => void): this;
+    off<K extends keyof ClientEventMap>(event: K, listener: (...args: ClientEventMap[K]) => void): this;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+    getConfiguration(): Configuration;
+    getEvaluator(): Evaluator;
+    isEnabled(flagKey: string, context?: EvaluationContext): boolean;
+    evaluate(flagKey: string, context?: EvaluationContext): EvaluationResult;
+    getVariant(flagKey: string, context?: EvaluationContext): VariantResult;
+    can(actionKey: string, context?: EvaluationContext): boolean;
+}
+
+declare function createEvaluator(configuration: Configuration): Evaluator;
+declare class EvaluatorManager {
+    private evaluator;
+    update(configuration: Configuration): void;
+    get(): Evaluator;
+    isReady(): boolean;
+}
+
+interface ConfigurationRepository {
+    initialize(): Promise<void>;
+    initializeWith(configuration: Configuration): void;
+    refresh(): Promise<boolean>;
+    getVersion(): number;
+    getConfiguration(): Configuration;
+    subscribe(listener: (configuration: Configuration) => void): () => void;
+}
+declare class HttpConfigurationRepository implements ConfigurationRepository {
+    private readonly apiUrl;
+    private readonly sdkKey;
+    private readonly requestTimeout;
+    private configuration;
+    private version;
+    private readonly listeners;
+    constructor(apiUrl: string, sdkKey: string, requestTimeout: number);
+    initialize(): Promise<void>;
+    initializeWith(configuration: Configuration): void;
+    refresh(): Promise<boolean>;
+    getVersion(): number;
+    getConfiguration(): Configuration;
+    subscribe(listener: (configuration: Configuration) => void): () => void;
+    private notify;
+    private fetchBootstrap;
+    private fetchVersion;
+    private request;
+}
+
+interface UpdateProvider {
+    start(onRefresh: () => void): void;
+    stop(): void;
+}
+declare class PollingUpdateProvider implements UpdateProvider {
+    private readonly interval;
+    private timer;
+    constructor(interval: number);
+    start(onRefresh: () => void): void;
+    stop(): void;
+}
+declare class SseUpdateProvider implements UpdateProvider {
+    private readonly apiUrl;
+    private readonly sdkKey;
+    private eventSource;
+    constructor(apiUrl: string, sdkKey: string);
+    start(onRefresh: () => void): void;
+    stop(): void;
+}
+
+declare class LocalStorageAdapter implements StorageAdapter {
+    private readonly key;
+    constructor(key?: string);
+    get(): Promise<Configuration | null>;
+    set(configuration: Configuration): Promise<void>;
+    clear(): Promise<void>;
+}
+
+export { type Configuration, type ConfigurationRepository, type Evaluator, EvaluatorManager, type FlagConfig, HttpConfigurationRepository, LocalStorageAdapter, PollingUpdateProvider, RolloutCtrlClient, type RolloutCtrlOptions, SseUpdateProvider, type StorageAdapter, type UpdateProvider, type VariantResult, createEvaluator };

package/dist/index.d.ts

@@ -0,0 +1,130 @@
+import { FeatureFlagEnvironment, Action, EvaluationContext, EvaluationResult } from '@rolloutctrl/evaluator';
+
+interface FlagConfig extends FeatureFlagEnvironment {
+    key: string;
+}
+interface Configuration {
+    projectId: string;
+    environmentId: string;
+    version: number;
+    flags: FlagConfig[];
+    actions: Action[];
+}
+type VariantResult = EvaluationResult['variant'];
+interface Evaluator {
+    isEnabled(flagKey: string, context?: EvaluationContext): boolean;
+    evaluate(flagKey: string, context?: EvaluationContext): EvaluationResult;
+    getVariant(flagKey: string, context?: EvaluationContext): VariantResult;
+    can(actionKey: string, context?: EvaluationContext): boolean;
+}
+interface StorageAdapter {
+    get(): Promise<Configuration | null>;
+    set(configuration: Configuration): Promise<void>;
+    clear(): Promise<void>;
+}
+interface RolloutCtrlOptions {
+    sdkKey: string;
+    apiUrl?: string;
+    refreshInterval?: number;
+    requestTimeout?: number;
+    bootstrap?: Configuration;
+    storage?: StorageAdapter;
+}
+
+type ClientEventMap = {
+    ready: [];
+    updated: [configuration: Configuration];
+    error: [error: Error];
+    shutdown: [];
+};
+declare class RolloutCtrlClient {
+    private readonly emitter;
+    private readonly repository;
+    private readonly evaluatorManager;
+    private readonly updateProvider;
+    private readonly subscribers;
+    private isInitialized;
+    private readonly readyPromise;
+    private resolveReady;
+    private rejectReady;
+    constructor(options: RolloutCtrlOptions);
+    private initialize;
+    on<K extends keyof ClientEventMap>(event: K, listener: (...args: ClientEventMap[K]) => void): this;
+    off<K extends keyof ClientEventMap>(event: K, listener: (...args: ClientEventMap[K]) => void): this;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+    getConfiguration(): Configuration;
+    getEvaluator(): Evaluator;
+    isEnabled(flagKey: string, context?: EvaluationContext): boolean;
+    evaluate(flagKey: string, context?: EvaluationContext): EvaluationResult;
+    getVariant(flagKey: string, context?: EvaluationContext): VariantResult;
+    can(actionKey: string, context?: EvaluationContext): boolean;
+}
+
+declare function createEvaluator(configuration: Configuration): Evaluator;
+declare class EvaluatorManager {
+    private evaluator;
+    update(configuration: Configuration): void;
+    get(): Evaluator;
+    isReady(): boolean;
+}
+
+interface ConfigurationRepository {
+    initialize(): Promise<void>;
+    initializeWith(configuration: Configuration): void;
+    refresh(): Promise<boolean>;
+    getVersion(): number;
+    getConfiguration(): Configuration;
+    subscribe(listener: (configuration: Configuration) => void): () => void;
+}
+declare class HttpConfigurationRepository implements ConfigurationRepository {
+    private readonly apiUrl;
+    private readonly sdkKey;
+    private readonly requestTimeout;
+    private configuration;
+    private version;
+    private readonly listeners;
+    constructor(apiUrl: string, sdkKey: string, requestTimeout: number);
+    initialize(): Promise<void>;
+    initializeWith(configuration: Configuration): void;
+    refresh(): Promise<boolean>;
+    getVersion(): number;
+    getConfiguration(): Configuration;
+    subscribe(listener: (configuration: Configuration) => void): () => void;
+    private notify;
+    private fetchBootstrap;
+    private fetchVersion;
+    private request;
+}
+
+interface UpdateProvider {
+    start(onRefresh: () => void): void;
+    stop(): void;
+}
+declare class PollingUpdateProvider implements UpdateProvider {
+    private readonly interval;
+    private timer;
+    constructor(interval: number);
+    start(onRefresh: () => void): void;
+    stop(): void;
+}
+declare class SseUpdateProvider implements UpdateProvider {
+    private readonly apiUrl;
+    private readonly sdkKey;
+    private eventSource;
+    constructor(apiUrl: string, sdkKey: string);
+    start(onRefresh: () => void): void;
+    stop(): void;
+}
+
+declare class LocalStorageAdapter implements StorageAdapter {
+    private readonly key;
+    constructor(key?: string);
+    get(): Promise<Configuration | null>;
+    set(configuration: Configuration): Promise<void>;
+    clear(): Promise<void>;
+}
+
+export { type Configuration, type ConfigurationRepository, type Evaluator, EvaluatorManager, type FlagConfig, HttpConfigurationRepository, LocalStorageAdapter, PollingUpdateProvider, RolloutCtrlClient, type RolloutCtrlOptions, SseUpdateProvider, type StorageAdapter, type UpdateProvider, type VariantResult, createEvaluator };

package/dist/index.js

@@ -0,0 +1,382 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EvaluatorManager: () => EvaluatorManager,
+  HttpConfigurationRepository: () => HttpConfigurationRepository,
+  LocalStorageAdapter: () => LocalStorageAdapter,
+  PollingUpdateProvider: () => PollingUpdateProvider,
+  RolloutCtrlClient: () => RolloutCtrlClient,
+  SseUpdateProvider: () => SseUpdateProvider,
+  createEvaluator: () => createEvaluator
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/emitter.ts
+var TinyEmitter = class {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    let set = this._listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this._listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this._listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+    }
+  }
+  removeAllListeners() {
+    this._listeners.clear();
+  }
+};
+
+// src/evaluator.ts
+var import_evaluator = require("@rolloutctrl/evaluator");
+function createEvaluator(configuration) {
+  const flagIndex = new Map(configuration.flags.map((f) => [f.key, f]));
+  const actionIndex = new Map(configuration.actions.map((a) => [a.key, a]));
+  return {
+    isEnabled(flagKey, context = {}) {
+      const flag = flagIndex.get(flagKey);
+      if (!flag) return false;
+      return (0, import_evaluator.evaluateFeatureFlag)(flag, context).enabled;
+    },
+    evaluate(flagKey, context = {}) {
+      const flag = flagIndex.get(flagKey);
+      if (!flag) {
+        return { enabled: false, reason: import_evaluator.EvaluationReason.DISABLED_FLAG };
+      }
+      return (0, import_evaluator.evaluateFeatureFlag)(flag, context);
+    },
+    getVariant(flagKey, context = {}) {
+      const flag = flagIndex.get(flagKey);
+      if (!flag) return void 0;
+      return (0, import_evaluator.evaluateFeatureFlag)(flag, context).variant;
+    },
+    can(actionKey, context = {}) {
+      const action = actionIndex.get(actionKey);
+      if (!action) return false;
+      return (0, import_evaluator.evaluateAction)(action, context).effect === "ALLOW";
+    }
+  };
+}
+var EvaluatorManager = class {
+  constructor() {
+    this.evaluator = null;
+  }
+  update(configuration) {
+    this.evaluator = createEvaluator(configuration);
+  }
+  get() {
+    if (!this.evaluator) {
+      throw new Error("RolloutCtrlClient is not ready. Await client.ready() first.");
+    }
+    return this.evaluator;
+  }
+  isReady() {
+    return this.evaluator !== null;
+  }
+};
+
+// src/repository.ts
+var HttpConfigurationRepository = class {
+  constructor(apiUrl, sdkKey, requestTimeout) {
+    this.apiUrl = apiUrl;
+    this.sdkKey = sdkKey;
+    this.requestTimeout = requestTimeout;
+    this.configuration = null;
+    this.version = 0;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  async initialize() {
+    const config = await this.fetchBootstrap();
+    this.configuration = config;
+    this.version = config.version;
+    this.notify(config);
+  }
+  initializeWith(configuration) {
+    this.configuration = configuration;
+    this.version = configuration.version;
+    this.notify(configuration);
+  }
+  async refresh() {
+    try {
+      const versionResponse = await this.fetchVersion();
+      if (versionResponse.version === this.version) {
+        return false;
+      }
+      const config = await this.fetchBootstrap();
+      this.configuration = config;
+      this.version = config.version;
+      this.notify(config);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getVersion() {
+    return this.version;
+  }
+  getConfiguration() {
+    if (!this.configuration) {
+      throw new Error("Configuration not initialized. Call initialize() first.");
+    }
+    return this.configuration;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify(configuration) {
+    for (const listener of this.listeners) {
+      listener(configuration);
+    }
+  }
+  async fetchBootstrap() {
+    return this.request(`${this.apiUrl}/sdk/bootstrap`);
+  }
+  async fetchVersion() {
+    return this.request(`${this.apiUrl}/sdk/version`);
+  }
+  async request(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.requestTimeout);
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${this.sdkKey}`,
+          "Content-Type": "application/json"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response.json();
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/update-provider.ts
+var PollingUpdateProvider = class {
+  constructor(interval) {
+    this.interval = interval;
+    this.timer = null;
+  }
+  start(onRefresh) {
+    this.stop();
+    this.timer = setInterval(onRefresh, this.interval);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+};
+var SseUpdateProvider = class {
+  constructor(apiUrl, sdkKey) {
+    this.apiUrl = apiUrl;
+    this.sdkKey = sdkKey;
+    this.eventSource = null;
+  }
+  start(onRefresh) {
+    this.stop();
+    if (typeof EventSource === "undefined") {
+      return;
+    }
+    const url = `${this.apiUrl}/sdk/stream?key=${encodeURIComponent(this.sdkKey)}`;
+    this.eventSource = new EventSource(url);
+    this.eventSource.addEventListener("configuration.updated", () => {
+      onRefresh();
+    });
+    this.eventSource.onerror = () => {
+      this.stop();
+    };
+  }
+  stop() {
+    if (this.eventSource !== null) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+};
+
+// src/client.ts
+var DEFAULT_API_URL = "https://rolloutctrl.io/api";
+var DEFAULT_REFRESH_INTERVAL = 3e4;
+var DEFAULT_REQUEST_TIMEOUT = 5e3;
+var RolloutCtrlClient = class {
+  constructor(options) {
+    this.emitter = new TinyEmitter();
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.isInitialized = false;
+    const apiUrl = options.apiUrl ?? DEFAULT_API_URL;
+    const refreshInterval = options.refreshInterval ?? DEFAULT_REFRESH_INTERVAL;
+    const requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this.repository = new HttpConfigurationRepository(apiUrl, options.sdkKey, requestTimeout);
+    this.evaluatorManager = new EvaluatorManager();
+    this.updateProvider = new PollingUpdateProvider(refreshInterval);
+    this.repository.subscribe((configuration) => {
+      this.evaluatorManager.update(configuration);
+      options.storage?.set(configuration).catch(() => {
+      });
+      if (this.isInitialized) {
+        for (const listener of this.subscribers) {
+          listener();
+        }
+        this.emitter.emit("updated", configuration);
+      }
+    });
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    void this.initialize(options);
+  }
+  async initialize(options) {
+    try {
+      if (options.bootstrap) {
+        this.repository.initializeWith(options.bootstrap);
+      } else if (options.storage) {
+        const cached = await options.storage.get();
+        if (cached) {
+          this.repository.initializeWith(cached);
+          void this.repository.refresh();
+        } else {
+          await this.repository.initialize();
+        }
+      } else {
+        await this.repository.initialize();
+      }
+      this.isInitialized = true;
+      this.updateProvider.start(() => {
+        void this.repository.refresh();
+      });
+      this.emitter.emit("ready");
+      this.resolveReady();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emitter.emit("error", err);
+      this.rejectReady(err);
+    }
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  ready() {
+    return this.readyPromise;
+  }
+  async close() {
+    this.updateProvider.stop();
+    this.subscribers.clear();
+    this.emitter.emit("shutdown");
+    this.emitter.removeAllListeners();
+  }
+  subscribe(listener) {
+    this.subscribers.add(listener);
+    return () => {
+      this.subscribers.delete(listener);
+    };
+  }
+  getVersion() {
+    return this.repository.getVersion();
+  }
+  getConfiguration() {
+    return this.repository.getConfiguration();
+  }
+  getEvaluator() {
+    return this.evaluatorManager.get();
+  }
+  isEnabled(flagKey, context) {
+    return this.getEvaluator().isEnabled(flagKey, context);
+  }
+  evaluate(flagKey, context) {
+    return this.getEvaluator().evaluate(flagKey, context);
+  }
+  getVariant(flagKey, context) {
+    return this.getEvaluator().getVariant(flagKey, context);
+  }
+  can(actionKey, context) {
+    return this.getEvaluator().can(actionKey, context);
+  }
+};
+
+// src/storage.ts
+var DEFAULT_STORAGE_KEY = "rolloutctrl:config";
+var LocalStorageAdapter = class {
+  constructor(key = DEFAULT_STORAGE_KEY) {
+    this.key = key;
+  }
+  async get() {
+    if (typeof localStorage === "undefined") return null;
+    try {
+      const raw = localStorage.getItem(this.key);
+      if (!raw) return null;
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async set(configuration) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(this.key, JSON.stringify(configuration));
+    } catch {
+    }
+  }
+  async clear() {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(this.key);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvaluatorManager,
+  HttpConfigurationRepository,
+  LocalStorageAdapter,
+  PollingUpdateProvider,
+  RolloutCtrlClient,
+  SseUpdateProvider,
+  createEvaluator
+});

package/dist/index.mjs

@@ -0,0 +1,353 @@
+// src/emitter.ts
+var TinyEmitter = class {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    let set = this._listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this._listeners.set(event, set);
+    }
+    set.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this._listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this._listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+    }
+  }
+  removeAllListeners() {
+    this._listeners.clear();
+  }
+};
+
+// src/evaluator.ts
+import {
+  evaluateFeatureFlag,
+  evaluateAction,
+  EvaluationReason
+} from "@rolloutctrl/evaluator";
+function createEvaluator(configuration) {
+  const flagIndex = new Map(configuration.flags.map((f) => [f.key, f]));
+  const actionIndex = new Map(configuration.actions.map((a) => [a.key, a]));
+  return {
+    isEnabled(flagKey, context = {}) {
+      const flag = flagIndex.get(flagKey);
+      if (!flag) return false;
+      return evaluateFeatureFlag(flag, context).enabled;
+    },
+    evaluate(flagKey, context = {}) {
+      const flag = flagIndex.get(flagKey);
+      if (!flag) {
+        return { enabled: false, reason: EvaluationReason.DISABLED_FLAG };
+      }
+      return evaluateFeatureFlag(flag, context);
+    },
+    getVariant(flagKey, context = {}) {
+      const flag = flagIndex.get(flagKey);
+      if (!flag) return void 0;
+      return evaluateFeatureFlag(flag, context).variant;
+    },
+    can(actionKey, context = {}) {
+      const action = actionIndex.get(actionKey);
+      if (!action) return false;
+      return evaluateAction(action, context).effect === "ALLOW";
+    }
+  };
+}
+var EvaluatorManager = class {
+  constructor() {
+    this.evaluator = null;
+  }
+  update(configuration) {
+    this.evaluator = createEvaluator(configuration);
+  }
+  get() {
+    if (!this.evaluator) {
+      throw new Error("RolloutCtrlClient is not ready. Await client.ready() first.");
+    }
+    return this.evaluator;
+  }
+  isReady() {
+    return this.evaluator !== null;
+  }
+};
+
+// src/repository.ts
+var HttpConfigurationRepository = class {
+  constructor(apiUrl, sdkKey, requestTimeout) {
+    this.apiUrl = apiUrl;
+    this.sdkKey = sdkKey;
+    this.requestTimeout = requestTimeout;
+    this.configuration = null;
+    this.version = 0;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  async initialize() {
+    const config = await this.fetchBootstrap();
+    this.configuration = config;
+    this.version = config.version;
+    this.notify(config);
+  }
+  initializeWith(configuration) {
+    this.configuration = configuration;
+    this.version = configuration.version;
+    this.notify(configuration);
+  }
+  async refresh() {
+    try {
+      const versionResponse = await this.fetchVersion();
+      if (versionResponse.version === this.version) {
+        return false;
+      }
+      const config = await this.fetchBootstrap();
+      this.configuration = config;
+      this.version = config.version;
+      this.notify(config);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getVersion() {
+    return this.version;
+  }
+  getConfiguration() {
+    if (!this.configuration) {
+      throw new Error("Configuration not initialized. Call initialize() first.");
+    }
+    return this.configuration;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  notify(configuration) {
+    for (const listener of this.listeners) {
+      listener(configuration);
+    }
+  }
+  async fetchBootstrap() {
+    return this.request(`${this.apiUrl}/sdk/bootstrap`);
+  }
+  async fetchVersion() {
+    return this.request(`${this.apiUrl}/sdk/version`);
+  }
+  async request(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.requestTimeout);
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${this.sdkKey}`,
+          "Content-Type": "application/json"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response.json();
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/update-provider.ts
+var PollingUpdateProvider = class {
+  constructor(interval) {
+    this.interval = interval;
+    this.timer = null;
+  }
+  start(onRefresh) {
+    this.stop();
+    this.timer = setInterval(onRefresh, this.interval);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+};
+var SseUpdateProvider = class {
+  constructor(apiUrl, sdkKey) {
+    this.apiUrl = apiUrl;
+    this.sdkKey = sdkKey;
+    this.eventSource = null;
+  }
+  start(onRefresh) {
+    this.stop();
+    if (typeof EventSource === "undefined") {
+      return;
+    }
+    const url = `${this.apiUrl}/sdk/stream?key=${encodeURIComponent(this.sdkKey)}`;
+    this.eventSource = new EventSource(url);
+    this.eventSource.addEventListener("configuration.updated", () => {
+      onRefresh();
+    });
+    this.eventSource.onerror = () => {
+      this.stop();
+    };
+  }
+  stop() {
+    if (this.eventSource !== null) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+};
+
+// src/client.ts
+var DEFAULT_API_URL = "https://rolloutctrl.io/api";
+var DEFAULT_REFRESH_INTERVAL = 3e4;
+var DEFAULT_REQUEST_TIMEOUT = 5e3;
+var RolloutCtrlClient = class {
+  constructor(options) {
+    this.emitter = new TinyEmitter();
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.isInitialized = false;
+    const apiUrl = options.apiUrl ?? DEFAULT_API_URL;
+    const refreshInterval = options.refreshInterval ?? DEFAULT_REFRESH_INTERVAL;
+    const requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this.repository = new HttpConfigurationRepository(apiUrl, options.sdkKey, requestTimeout);
+    this.evaluatorManager = new EvaluatorManager();
+    this.updateProvider = new PollingUpdateProvider(refreshInterval);
+    this.repository.subscribe((configuration) => {
+      this.evaluatorManager.update(configuration);
+      options.storage?.set(configuration).catch(() => {
+      });
+      if (this.isInitialized) {
+        for (const listener of this.subscribers) {
+          listener();
+        }
+        this.emitter.emit("updated", configuration);
+      }
+    });
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    void this.initialize(options);
+  }
+  async initialize(options) {
+    try {
+      if (options.bootstrap) {
+        this.repository.initializeWith(options.bootstrap);
+      } else if (options.storage) {
+        const cached = await options.storage.get();
+        if (cached) {
+          this.repository.initializeWith(cached);
+          void this.repository.refresh();
+        } else {
+          await this.repository.initialize();
+        }
+      } else {
+        await this.repository.initialize();
+      }
+      this.isInitialized = true;
+      this.updateProvider.start(() => {
+        void this.repository.refresh();
+      });
+      this.emitter.emit("ready");
+      this.resolveReady();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.emitter.emit("error", err);
+      this.rejectReady(err);
+    }
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+    return this;
+  }
+  ready() {
+    return this.readyPromise;
+  }
+  async close() {
+    this.updateProvider.stop();
+    this.subscribers.clear();
+    this.emitter.emit("shutdown");
+    this.emitter.removeAllListeners();
+  }
+  subscribe(listener) {
+    this.subscribers.add(listener);
+    return () => {
+      this.subscribers.delete(listener);
+    };
+  }
+  getVersion() {
+    return this.repository.getVersion();
+  }
+  getConfiguration() {
+    return this.repository.getConfiguration();
+  }
+  getEvaluator() {
+    return this.evaluatorManager.get();
+  }
+  isEnabled(flagKey, context) {
+    return this.getEvaluator().isEnabled(flagKey, context);
+  }
+  evaluate(flagKey, context) {
+    return this.getEvaluator().evaluate(flagKey, context);
+  }
+  getVariant(flagKey, context) {
+    return this.getEvaluator().getVariant(flagKey, context);
+  }
+  can(actionKey, context) {
+    return this.getEvaluator().can(actionKey, context);
+  }
+};
+
+// src/storage.ts
+var DEFAULT_STORAGE_KEY = "rolloutctrl:config";
+var LocalStorageAdapter = class {
+  constructor(key = DEFAULT_STORAGE_KEY) {
+    this.key = key;
+  }
+  async get() {
+    if (typeof localStorage === "undefined") return null;
+    try {
+      const raw = localStorage.getItem(this.key);
+      if (!raw) return null;
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async set(configuration) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(this.key, JSON.stringify(configuration));
+    } catch {
+    }
+  }
+  async clear() {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(this.key);
+  }
+};
+export {
+  EvaluatorManager,
+  HttpConfigurationRepository,
+  LocalStorageAdapter,
+  PollingUpdateProvider,
+  RolloutCtrlClient,
+  SseUpdateProvider,
+  createEvaluator
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@rolloutctrl/js-sdk",
+  "version": "0.0.1",
+  "description": "RolloutCtrl JavaScript SDK for browser applications",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@rolloutctrl/evaluator": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "ts-jest": "^29.1.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}