@openfeature/web-sdk 0.0.2-experimental → 0.2.0-experimental

package/dist/esm/index.js

@@ -1,7 +1,11 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -17,6 +21,25 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -38,6 +61,378 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// ../../node_modules/events/events.js
+var require_events = __commonJS({
+  "../../node_modules/events/events.js"(exports, module) {
+    "use strict";
+    var R = typeof Reflect === "object" ? Reflect : null;
+    var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+      return Function.prototype.apply.call(target, receiver, args);
+    };
+    var ReflectOwnKeys;
+    if (R && typeof R.ownKeys === "function") {
+      ReflectOwnKeys = R.ownKeys;
+    } else if (Object.getOwnPropertySymbols) {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+      };
+    } else {
+      ReflectOwnKeys = function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target);
+      };
+    }
+    function ProcessEmitWarning(warning) {
+      if (console && console.warn)
+        console.warn(warning);
+    }
+    var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+      return value !== value;
+    };
+    function EventEmitter2() {
+      EventEmitter2.init.call(this);
+    }
+    module.exports = EventEmitter2;
+    module.exports.once = once;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    EventEmitter2.prototype._events = void 0;
+    EventEmitter2.prototype._eventsCount = 0;
+    EventEmitter2.prototype._maxListeners = void 0;
+    var defaultMaxListeners = 10;
+    function checkListener(listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+      }
+    }
+    Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
+      enumerable: true,
+      get: function() {
+        return defaultMaxListeners;
+      },
+      set: function(arg) {
+        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+        }
+        defaultMaxListeners = arg;
+      }
+    });
+    EventEmitter2.init = function() {
+      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      }
+      this._maxListeners = this._maxListeners || void 0;
+    };
+    EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n) {
+      if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+      }
+      this._maxListeners = n;
+      return this;
+    };
+    function _getMaxListeners(that) {
+      if (that._maxListeners === void 0)
+        return EventEmitter2.defaultMaxListeners;
+      return that._maxListeners;
+    }
+    EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
+      return _getMaxListeners(this);
+    };
+    EventEmitter2.prototype.emit = function emit(type) {
+      var args = [];
+      for (var i = 1; i < arguments.length; i++)
+        args.push(arguments[i]);
+      var doError = type === "error";
+      var events = this._events;
+      if (events !== void 0)
+        doError = doError && events.error === void 0;
+      else if (!doError)
+        return false;
+      if (doError) {
+        var er;
+        if (args.length > 0)
+          er = args[0];
+        if (er instanceof Error) {
+          throw er;
+        }
+        var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+        err.context = er;
+        throw err;
+      }
+      var handler = events[type];
+      if (handler === void 0)
+        return false;
+      if (typeof handler === "function") {
+        ReflectApply(handler, this, args);
+      } else {
+        var len = handler.length;
+        var listeners = arrayClone(handler, len);
+        for (var i = 0; i < len; ++i)
+          ReflectApply(listeners[i], this, args);
+      }
+      return true;
+    };
+    function _addListener(target, type, listener, prepend) {
+      var m;
+      var events;
+      var existing;
+      checkListener(listener);
+      events = target._events;
+      if (events === void 0) {
+        events = target._events = /* @__PURE__ */ Object.create(null);
+        target._eventsCount = 0;
+      } else {
+        if (events.newListener !== void 0) {
+          target.emit(
+            "newListener",
+            type,
+            listener.listener ? listener.listener : listener
+          );
+          events = target._events;
+        }
+        existing = events[type];
+      }
+      if (existing === void 0) {
+        existing = events[type] = listener;
+        ++target._eventsCount;
+      } else {
+        if (typeof existing === "function") {
+          existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+        } else if (prepend) {
+          existing.unshift(listener);
+        } else {
+          existing.push(listener);
+        }
+        m = _getMaxListeners(target);
+        if (m > 0 && existing.length > m && !existing.warned) {
+          existing.warned = true;
+          var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+          w.name = "MaxListenersExceededWarning";
+          w.emitter = target;
+          w.type = type;
+          w.count = existing.length;
+          ProcessEmitWarning(w);
+        }
+      }
+      return target;
+    }
+    EventEmitter2.prototype.addListener = function addListener(type, listener) {
+      return _addListener(this, type, listener, false);
+    };
+    EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
+    EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
+    function onceWrapper() {
+      if (!this.fired) {
+        this.target.removeListener(this.type, this.wrapFn);
+        this.fired = true;
+        if (arguments.length === 0)
+          return this.listener.call(this.target);
+        return this.listener.apply(this.target, arguments);
+      }
+    }
+    function _onceWrap(target, type, listener) {
+      var state = { fired: false, wrapFn: void 0, target, type, listener };
+      var wrapped = onceWrapper.bind(state);
+      wrapped.listener = listener;
+      state.wrapFn = wrapped;
+      return wrapped;
+    }
+    EventEmitter2.prototype.once = function once2(type, listener) {
+      checkListener(listener);
+      this.on(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+      checkListener(listener);
+      events = this._events;
+      if (events === void 0)
+        return this;
+      list = events[type];
+      if (list === void 0)
+        return this;
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit("removeListener", type, list.listener || listener);
+        }
+      } else if (typeof list !== "function") {
+        position = -1;
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+        if (position < 0)
+          return this;
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
+        if (list.length === 1)
+          events[type] = list[0];
+        if (events.removeListener !== void 0)
+          this.emit("removeListener", type, originalListener || listener);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
+      var listeners, events, i;
+      events = this._events;
+      if (events === void 0)
+        return this;
+      if (events.removeListener === void 0) {
+        if (arguments.length === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== void 0) {
+          if (--this._eventsCount === 0)
+            this._events = /* @__PURE__ */ Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === "removeListener")
+            continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners("removeListener");
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+      listeners = events[type];
+      if (typeof listeners === "function") {
+        this.removeListener(type, listeners);
+      } else if (listeners !== void 0) {
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+      return this;
+    };
+    function _listeners(target, type, unwrap) {
+      var events = target._events;
+      if (events === void 0)
+        return [];
+      var evlistener = events[type];
+      if (evlistener === void 0)
+        return [];
+      if (typeof evlistener === "function")
+        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+      return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+    }
+    EventEmitter2.prototype.listeners = function listeners(type) {
+      return _listeners(this, type, true);
+    };
+    EventEmitter2.prototype.rawListeners = function rawListeners(type) {
+      return _listeners(this, type, false);
+    };
+    EventEmitter2.listenerCount = function(emitter, type) {
+      if (typeof emitter.listenerCount === "function") {
+        return emitter.listenerCount(type);
+      } else {
+        return listenerCount.call(emitter, type);
+      }
+    };
+    EventEmitter2.prototype.listenerCount = listenerCount;
+    function listenerCount(type) {
+      var events = this._events;
+      if (events !== void 0) {
+        var evlistener = events[type];
+        if (typeof evlistener === "function") {
+          return 1;
+        } else if (evlistener !== void 0) {
+          return evlistener.length;
+        }
+      }
+      return 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+    };
+    function arrayClone(arr, n) {
+      var copy = new Array(n);
+      for (var i = 0; i < n; ++i)
+        copy[i] = arr[i];
+      return copy;
+    }
+    function spliceOne(list, index) {
+      for (; index + 1 < list.length; index++)
+        list[index] = list[index + 1];
+      list.pop();
+    }
+    function unwrapListeners(arr) {
+      var ret = new Array(arr.length);
+      for (var i = 0; i < ret.length; ++i) {
+        ret[i] = arr[i].listener || arr[i];
+      }
+      return ret;
+    }
+    function once(emitter, name) {
+      return new Promise(function(resolve, reject) {
+        function errorListener(err) {
+          emitter.removeListener(name, resolver);
+          reject(err);
+        }
+        function resolver() {
+          if (typeof emitter.removeListener === "function") {
+            emitter.removeListener("error", errorListener);
+          }
+          resolve([].slice.call(arguments));
+        }
+        ;
+        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+        if (name !== "error") {
+          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+        }
+      });
+    }
+    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+      if (typeof emitter.on === "function") {
+        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+      }
+    }
+    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+      if (typeof emitter.on === "function") {
+        if (flags.once) {
+          emitter.once(name, listener);
+        } else {
+          emitter.on(name, listener);
+        }
+      } else if (typeof emitter.addEventListener === "function") {
+        emitter.addEventListener(name, function wrapListener(arg) {
+          if (flags.once) {
+            emitter.removeEventListener(name, wrapListener);
+          }
+          listener(arg);
+        });
+      } else {
+        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+      }
+    }
+  }
+});
+
 // ../shared/src/types.ts
 var ProviderEvents = /* @__PURE__ */ ((ProviderEvents2) => {
   ProviderEvents2["Ready"] = "PROVIDER_READY";
@@ -264,6 +659,9 @@ var OpenFeatureCommonAPI = class {
   }
 };
 
+// src/open-feature.ts
+var import_events = __toESM(require_events());
+
 // src/no-op-provider.ts
 var REASON_NO_OP = "No-op";
 var NoopFeatureProvider = class {
@@ -300,6 +698,8 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   constructor() {
     super();
+    this._apiEvents = new import_events.EventEmitter();
+    this._providerReady = false;
     this._hooks = [];
     this._provider = NOOP_PROVIDER;
   }
@@ -350,12 +750,29 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
     });
   }
   setProvider(provider) {
-    var _a;
+    var _a, _b, _c, _d, _e, _f, _g;
     if (this._provider !== provider) {
       const oldProvider = this._provider;
       this._provider = provider;
-      window.dispatchEvent(new CustomEvent("providerChanged" /* ProviderChanged */));
-      (_a = oldProvider == null ? void 0 : oldProvider.onClose) == null ? void 0 : _a.call(oldProvider);
+      this._providerReady = false;
+      if (!this._provider.events) {
+        this._provider.events = new import_events.EventEmitter();
+      }
+      if (typeof ((_a = this._provider) == null ? void 0 : _a.initialize) === "function") {
+        (_e = (_d = (_c = (_b = this._provider).initialize) == null ? void 0 : _c.call(_b, this._context)) == null ? void 0 : _d.then(() => {
+          var _a2;
+          this._providerReady = true;
+          (_a2 = this._provider.events) == null ? void 0 : _a2.emit("PROVIDER_READY" /* Ready */);
+        })) == null ? void 0 : _e.catch(() => {
+          var _a2;
+          (_a2 = this._provider.events) == null ? void 0 : _a2.emit("PROVIDER_ERROR" /* Error */);
+        });
+      } else {
+        this._providerReady = true;
+        (_f = this._provider.events) == null ? void 0 : _f.emit("PROVIDER_READY" /* Ready */);
+      }
+      this._apiEvents.emit("providerChanged" /* ProviderChanged */);
+      (_g = oldProvider == null ? void 0 : oldProvider.onClose) == null ? void 0 : _g.call(oldProvider);
     }
     return this;
   }
@@ -365,12 +782,15 @@ var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
       yield (_b = (_a = this == null ? void 0 : this._provider) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
     });
   }
-  getClient(name, version, context) {
+  getClient(name, version) {
     return new OpenFeatureClient(
+      // functions are passed here to make sure that these values are always up to date,
+      // and so we don't have to make these public properties on the API class. 
       () => this._provider,
+      () => this._providerReady,
+      () => this._apiEvents,
       () => this._logger,
-      { name, version },
-      context
+      { name, version }
     );
   }
 };
@@ -378,8 +798,9 @@ var OpenFeature = OpenFeatureAPI.getInstance();
 
 // src/client.ts
 var OpenFeatureClient = class {
-  constructor(providerAccessor, globalLogger, options, context = {}) {
+  constructor(providerAccessor, providerReady, apiEvents, globalLogger, options) {
     this.providerAccessor = providerAccessor;
+    this.providerReady = providerReady;
     this.globalLogger = globalLogger;
     this._hooks = [];
     this._handlerWrappers = [];
@@ -387,13 +808,14 @@ var OpenFeatureClient = class {
       name: options.name,
       version: options.version
     };
-    this._context = context;
     this.attachListeners();
-    window.dispatchEvent(new CustomEvent("providerChanged" /* ProviderChanged */));
+    apiEvents().on("providerChanged" /* ProviderChanged */, () => {
+      this.attachListeners();
+    });
   }
   addHandler(eventType, handler) {
     this._handlerWrappers.push({ eventType, handler });
-    if (eventType === "PROVIDER_READY" /* Ready */ && this.providerAccessor().ready) {
+    if (eventType === "PROVIDER_READY" /* Ready */ && this.providerReady()) {
       handler();
     }
   }
@@ -412,54 +834,51 @@ var OpenFeatureClient = class {
     this._hooks = [];
     return this;
   }
-  getBooleanValue(flagKey, defaultValue, context, options) {
-    return this.getBooleanDetails(flagKey, defaultValue, context, options).value;
+  getBooleanValue(flagKey, defaultValue, options) {
+    return this.getBooleanDetails(flagKey, defaultValue, options).value;
   }
-  getBooleanDetails(flagKey, defaultValue, context, options) {
+  getBooleanDetails(flagKey, defaultValue, options) {
     return this.evaluate(
       flagKey,
       this._provider.resolveBooleanEvaluation,
       defaultValue,
       "boolean",
-      context,
       options
     );
   }
-  getStringValue(flagKey, defaultValue, context, options) {
-    return this.getStringDetails(flagKey, defaultValue, context, options).value;
+  getStringValue(flagKey, defaultValue, options) {
+    return this.getStringDetails(flagKey, defaultValue, options).value;
   }
-  getStringDetails(flagKey, defaultValue, context, options) {
+  getStringDetails(flagKey, defaultValue, options) {
     return this.evaluate(
       flagKey,
       // this isolates providers from our restricted string generic argument.
       this._provider.resolveStringEvaluation,
       defaultValue,
       "string",
-      context,
       options
     );
   }
-  getNumberValue(flagKey, defaultValue, context, options) {
-    return this.getNumberDetails(flagKey, defaultValue, context, options).value;
+  getNumberValue(flagKey, defaultValue, options) {
+    return this.getNumberDetails(flagKey, defaultValue, options).value;
   }
-  getNumberDetails(flagKey, defaultValue, context, options) {
+  getNumberDetails(flagKey, defaultValue, options) {
     return this.evaluate(
       flagKey,
       // this isolates providers from our restricted number generic argument.
       this._provider.resolveNumberEvaluation,
       defaultValue,
       "number",
-      context,
       options
     );
   }
-  getObjectValue(flagKey, defaultValue, context, options) {
-    return this.getObjectDetails(flagKey, defaultValue, context, options).value;
+  getObjectValue(flagKey, defaultValue, options) {
+    return this.getObjectDetails(flagKey, defaultValue, options).value;
   }
-  getObjectDetails(flagKey, defaultValue, context, options) {
-    return this.evaluate(flagKey, this._provider.resolveObjectEvaluation, defaultValue, "object", context, options);
+  getObjectDetails(flagKey, defaultValue, options) {
+    return this.evaluate(flagKey, this._provider.resolveObjectEvaluation, defaultValue, "object", options);
   }
-  evaluate(flagKey, resolver, defaultValue, flagType, invocationContext = {}, options = {}) {
+  evaluate(flagKey, resolver, defaultValue, flagType, options = {}) {
     const allHooks = [
       ...OpenFeature.getHooks(),
       ...this.getHooks(),
@@ -467,19 +886,19 @@ var OpenFeatureClient = class {
       ...this._provider.hooks || []
     ];
     const allHooksReversed = [...allHooks].reverse();
-    const mergedContext = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, OpenFeature.getContext()), OpenFeature.getTransactionContext()), this._context), invocationContext);
+    const context = __spreadValues({}, OpenFeature.getContext());
     const hookContext = {
       flagKey,
       defaultValue,
       flagValueType: flagType,
       clientMetadata: this.metadata,
       providerMetadata: OpenFeature.providerMetadata,
-      context: mergedContext,
+      context,
       logger: this._logger
     };
     try {
-      const frozenContext = this.beforeHooks(allHooks, hookContext, options);
-      const resolution = resolver.call(this._provider, flagKey, defaultValue, frozenContext, this._logger);
+      this.beforeHooks(allHooks, hookContext, options);
+      const resolution = resolver.call(this._provider, flagKey, defaultValue, context, this._logger);
       const evaluationDetails = __spreadProps(__spreadValues({}, resolution), {
         flagKey
       });
@@ -549,9 +968,12 @@ var OpenFeatureClient = class {
     return this._clientLogger || this.globalLogger();
   }
   attachListeners() {
-    Object.values(ProviderEvents).forEach((eventType) => window.addEventListener(eventType, () => {
-      this._handlerWrappers.filter((wrapper) => wrapper.eventType === eventType).forEach((wrapper) => wrapper.handler());
-    }));
+    Object.values(ProviderEvents).forEach((eventType) => {
+      var _a;
+      return (_a = this._provider.events) == null ? void 0 : _a.on(eventType, () => {
+        this._handlerWrappers.filter((wrapper) => wrapper.eventType === eventType).forEach((wrapper) => wrapper.handler());
+      });
+    });
   }
 };
 export {