@schematichq/schematic-react 1.0.2 → 1.1.0

package/dist/schematic-react.esm.js

@@ -28,11 +28,12 @@ var require_browser_polyfill = __commonJS({
   "node_modules/cross-fetch/dist/browser-polyfill.js"(exports) {
     (function(self2) {
       var irrelevant = function(exports2) {
-        var global = typeof globalThis !== "undefined" && globalThis || typeof self2 !== "undefined" && self2 || typeof global !== "undefined" && global;
+        var g = typeof globalThis !== "undefined" && globalThis || typeof self2 !== "undefined" && self2 || // eslint-disable-next-line no-undef
+        typeof global !== "undefined" && global || {};
         var support = {
-          searchParams: "URLSearchParams" in global,
-          iterable: "Symbol" in global && "iterator" in Symbol,
-          blob: "FileReader" in global && "Blob" in global && function() {
+          searchParams: "URLSearchParams" in g,
+          iterable: "Symbol" in g && "iterator" in Symbol,
+          blob: "FileReader" in g && "Blob" in g && function() {
             try {
               new Blob();
               return true;
@@ -40,8 +41,8 @@ var require_browser_polyfill = __commonJS({
               return false;
             }
           }(),
-          formData: "FormData" in global,
-          arrayBuffer: "ArrayBuffer" in global
+          formData: "FormData" in g,
+          arrayBuffer: "ArrayBuffer" in g
         };
         function isDataView(obj) {
           return obj && DataView.prototype.isPrototypeOf(obj);
@@ -99,6 +100,9 @@ var require_browser_polyfill = __commonJS({
             }, this);
           } else if (Array.isArray(headers)) {
             headers.forEach(function(header) {
+              if (header.length != 2) {
+                throw new TypeError("Headers constructor: expected name/value pair to be length 2, found" + header.length);
+              }
               this.append(header[0], header[1]);
             }, this);
           } else if (headers) {
@@ -158,6 +162,7 @@ var require_browser_polyfill = __commonJS({
           Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
         }
         function consumed(body) {
+          if (body._noBody) return;
           if (body.bodyUsed) {
             return Promise.reject(new TypeError("Already read"));
           }
@@ -182,14 +187,16 @@ var require_browser_polyfill = __commonJS({
         function readBlobAsText(blob) {
           var reader = new FileReader();
           var promise = fileReaderReady(reader);
-          reader.readAsText(blob);
+          var match = /charset=([A-Za-z0-9_-]+)/.exec(blob.type);
+          var encoding = match ? match[1] : "utf-8";
+          reader.readAsText(blob, encoding);
           return promise;
         }
         function readArrayBufferAsText(buf) {
           var view = new Uint8Array(buf);
           var chars = new Array(view.length);
-          for (var i2 = 0; i2 < view.length; i2++) {
-            chars[i2] = String.fromCharCode(view[i2]);
+          for (var i = 0; i < view.length; i++) {
+            chars[i] = String.fromCharCode(view[i]);
           }
           return chars.join("");
         }
@@ -208,6 +215,7 @@ var require_browser_polyfill = __commonJS({
             this.bodyUsed = this.bodyUsed;
             this._bodyInit = body;
             if (!body) {
+              this._noBody = true;
               this._bodyText = "";
             } else if (typeof body === "string") {
               this._bodyText = body;
@@ -251,27 +259,28 @@ var require_browser_polyfill = __commonJS({
                 return Promise.resolve(new Blob([this._bodyText]));
               }
             };
-            this.arrayBuffer = function() {
-              if (this._bodyArrayBuffer) {
-                var isConsumed = consumed(this);
-                if (isConsumed) {
-                  return isConsumed;
-                }
-                if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
-                  return Promise.resolve(
-                    this._bodyArrayBuffer.buffer.slice(
-                      this._bodyArrayBuffer.byteOffset,
-                      this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
-                    )
-                  );
-                } else {
-                  return Promise.resolve(this._bodyArrayBuffer);
-                }
+          }
+          this.arrayBuffer = function() {
+            if (this._bodyArrayBuffer) {
+              var isConsumed = consumed(this);
+              if (isConsumed) {
+                return isConsumed;
+              } else if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+                return Promise.resolve(
+                  this._bodyArrayBuffer.buffer.slice(
+                    this._bodyArrayBuffer.byteOffset,
+                    this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+                  )
+                );
               } else {
-                return this.blob().then(readBlobAsArrayBuffer);
+                return Promise.resolve(this._bodyArrayBuffer);
               }
-            };
-          }
+            } else if (support.blob) {
+              return this.blob().then(readBlobAsArrayBuffer);
+            } else {
+              throw new Error("could not read as ArrayBuffer");
+            }
+          };
           this.text = function() {
             var rejected = consumed(this);
             if (rejected) {
@@ -297,7 +306,7 @@ var require_browser_polyfill = __commonJS({
           };
           return this;
         }
-        var methods = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
+        var methods = ["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE"];
         function normalizeMethod(method) {
           var upcased = method.toUpperCase();
           return methods.indexOf(upcased) > -1 ? upcased : method;
@@ -333,7 +342,12 @@ var require_browser_polyfill = __commonJS({
           }
           this.method = normalizeMethod(options.method || this.method || "GET");
           this.mode = options.mode || this.mode || null;
-          this.signal = options.signal || this.signal;
+          this.signal = options.signal || this.signal || function() {
+            if ("AbortController" in g) {
+              var ctrl = new AbortController();
+              return ctrl.signal;
+            }
+          }();
           this.referrer = null;
           if ((this.method === "GET" || this.method === "HEAD") && body) {
             throw new TypeError("Body not allowed for GET or HEAD requests");
@@ -376,7 +390,11 @@ var require_browser_polyfill = __commonJS({
             var key = parts.shift().trim();
             if (key) {
               var value = parts.join(":").trim();
-              headers.append(key, value);
+              try {
+                headers.append(key, value);
+              } catch (error) {
+                console.warn("Response " + error.message);
+              }
             }
           });
           return headers;
@@ -391,6 +409,9 @@ var require_browser_polyfill = __commonJS({
           }
           this.type = "default";
           this.status = options.status === void 0 ? 200 : options.status;
+          if (this.status < 200 || this.status > 599) {
+            throw new RangeError("Failed to construct 'Response': The status provided (0) is outside the range [200, 599].");
+          }
           this.ok = this.status >= 200 && this.status < 300;
           this.statusText = options.statusText === void 0 ? "" : "" + options.statusText;
           this.headers = new Headers(options.headers);
@@ -407,7 +428,9 @@ var require_browser_polyfill = __commonJS({
           });
         };
         Response.error = function() {
-          var response = new Response(null, { status: 0, statusText: "" });
+          var response = new Response(null, { status: 200, statusText: "" });
+          response.ok = false;
+          response.status = 0;
           response.type = "error";
           return response;
         };
@@ -418,7 +441,7 @@ var require_browser_polyfill = __commonJS({
           }
           return new Response(null, { status, headers: { location: url } });
         };
-        exports2.DOMException = global.DOMException;
+        exports2.DOMException = g.DOMException;
         try {
           new exports2.DOMException();
         } catch (err) {
@@ -443,10 +466,14 @@ var require_browser_polyfill = __commonJS({
             }
             xhr.onload = function() {
               var options = {
-                status: xhr.status,
                 statusText: xhr.statusText,
                 headers: parseHeaders(xhr.getAllResponseHeaders() || "")
               };
+              if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
+                options.status = 200;
+              } else {
+                options.status = xhr.status;
+              }
               options.url = "responseURL" in xhr ? xhr.responseURL : options.headers.get("X-Request-URL");
               var body = "response" in xhr ? xhr.response : xhr.responseText;
               setTimeout(function() {
@@ -460,7 +487,7 @@ var require_browser_polyfill = __commonJS({
             };
             xhr.ontimeout = function() {
               setTimeout(function() {
-                reject(new TypeError("Network request failed"));
+                reject(new TypeError("Network request timed out"));
               }, 0);
             };
             xhr.onabort = function() {
@@ -470,7 +497,7 @@ var require_browser_polyfill = __commonJS({
             };
             function fixUrl(url) {
               try {
-                return url === "" && global.location.href ? global.location.href : url;
+                return url === "" && g.location.href ? g.location.href : url;
               } catch (e) {
                 return url;
               }
@@ -484,14 +511,21 @@ var require_browser_polyfill = __commonJS({
             if ("responseType" in xhr) {
               if (support.blob) {
                 xhr.responseType = "blob";
-              } else if (support.arrayBuffer && request.headers.get("Content-Type") && request.headers.get("Content-Type").indexOf("application/octet-stream") !== -1) {
+              } else if (support.arrayBuffer) {
                 xhr.responseType = "arraybuffer";
               }
             }
-            if (init && typeof init.headers === "object" && !(init.headers instanceof Headers)) {
+            if (init && typeof init.headers === "object" && !(init.headers instanceof Headers || g.Headers && init.headers instanceof g.Headers)) {
+              var names = [];
               Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+                names.push(normalizeName(name));
                 xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
               });
+              request.headers.forEach(function(value, name) {
+                if (names.indexOf(name) === -1) {
+                  xhr.setRequestHeader(name, value);
+                }
+              });
             } else {
               request.headers.forEach(function(value, name) {
                 xhr.setRequestHeader(name, value);
@@ -509,11 +543,11 @@ var require_browser_polyfill = __commonJS({
           });
         }
         fetch2.polyfill = true;
-        if (!global.fetch) {
-          global.fetch = fetch2;
-          global.Headers = Headers;
-          global.Request = Request;
-          global.Response = Response;
+        if (!g.fetch) {
+          g.fetch = fetch2;
+          g.Headers = Headers;
+          g.Request = Request;
+          g.Response = Response;
         }
         exports2.Headers = Headers;
         exports2.Request = Request;
@@ -525,10 +559,9 @@ var require_browser_polyfill = __commonJS({
   }
 });
 var byteToHex = [];
-for (i = 0; i < 256; ++i) {
+for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
 }
-var i;
 function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
@@ -536,29 +569,33 @@ var getRandomValues;
 var rnds8 = new Uint8Array(16);
 function rng() {
   if (!getRandomValues) {
-    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
-    if (!getRandomValues) {
+    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
       throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
     }
+    getRandomValues = crypto.getRandomValues.bind(crypto);
   }
   return getRandomValues(rnds8);
 }
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-var native_default = {
-  randomUUID
-};
+var native_default = { randomUUID };
 function v4(options, buf, offset) {
   if (native_default.randomUUID && !buf && !options) {
     return native_default.randomUUID();
   }
   options = options || {};
-  var rnds = options.random || (options.rng || rng)();
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   if (buf) {
     offset = offset || 0;
-    for (var i2 = 0; i2 < 16; ++i2) {
-      buf[offset + i2] = rnds[i2];
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
     }
     return buf;
   }
@@ -566,6 +603,117 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 var import_polyfill = __toESM(require_browser_polyfill());
+function CheckFlagResponseDataFromJSON(json) {
+  return CheckFlagResponseDataFromJSONTyped(json, false);
+}
+function CheckFlagResponseDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    companyId: json["company_id"] == null ? void 0 : json["company_id"],
+    error: json["error"] == null ? void 0 : json["error"],
+    featureAllocation: json["feature_allocation"] == null ? void 0 : json["feature_allocation"],
+    featureUsage: json["feature_usage"] == null ? void 0 : json["feature_usage"],
+    featureUsagePeriod: json["feature_usage_period"] == null ? void 0 : json["feature_usage_period"],
+    featureUsageResetAt: json["feature_usage_reset_at"] == null ? void 0 : new Date(json["feature_usage_reset_at"]),
+    flag: json["flag"],
+    flagId: json["flag_id"] == null ? void 0 : json["flag_id"],
+    reason: json["reason"],
+    ruleId: json["rule_id"] == null ? void 0 : json["rule_id"],
+    ruleType: json["rule_type"] == null ? void 0 : json["rule_type"],
+    userId: json["user_id"] == null ? void 0 : json["user_id"],
+    value: json["value"]
+  };
+}
+function CheckFlagResponseFromJSON(json) {
+  return CheckFlagResponseFromJSONTyped(json, false);
+}
+function CheckFlagResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    data: CheckFlagResponseDataFromJSON(json["data"]),
+    params: json["params"]
+  };
+}
+function CheckFlagsResponseDataFromJSON(json) {
+  return CheckFlagsResponseDataFromJSONTyped(json, false);
+}
+function CheckFlagsResponseDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    flags: json["flags"].map(CheckFlagResponseDataFromJSON)
+  };
+}
+function CheckFlagsResponseFromJSON(json) {
+  return CheckFlagsResponseFromJSONTyped(json, false);
+}
+function CheckFlagsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    data: CheckFlagsResponseDataFromJSON(json["data"]),
+    params: json["params"]
+  };
+}
+var RuleType = /* @__PURE__ */ ((RuleType2) => {
+  RuleType2["GLOBAL_OVERRIDE"] = "global_override";
+  RuleType2["COMPANY_OVERRIDE"] = "company_override";
+  RuleType2["COMPANY_OVERRIDE_USAGE_EXCEEDED"] = "company_override_usage_exceeded";
+  RuleType2["PLAN_ENTITLEMENT"] = "plan_entitlement";
+  RuleType2["PLAN_ENTITLEMENT_USAGE_EXCEEDED"] = "plan_entitlement_usage_exceeded";
+  RuleType2["STANDARD"] = "standard";
+  RuleType2["DEFAULT"] = "default";
+  return RuleType2;
+})(RuleType || {});
+var UsagePeriod = /* @__PURE__ */ ((UsagePeriod2) => {
+  UsagePeriod2["ALL_TIME"] = "all_time";
+  UsagePeriod2["CURRENT_DAY"] = "current_day";
+  UsagePeriod2["CURRENT_MONTH"] = "current_month";
+  UsagePeriod2["CURRENT_WEEK"] = "current_week";
+  return UsagePeriod2;
+})(UsagePeriod || {});
+var CheckFlagReturnFromJSON = (json) => {
+  const {
+    companyId,
+    error,
+    featureAllocation,
+    featureUsage,
+    featureUsagePeriod,
+    featureUsageResetAt,
+    flag,
+    flagId,
+    reason,
+    ruleId,
+    ruleType,
+    userId,
+    value
+  } = CheckFlagResponseDataFromJSON(json);
+  const featureUsageExceeded = !value && // if flag is not false, then we haven't exceeded usage
+  (ruleType == "company_override_usage_exceeded" || // if the rule type is one of these, then we have exceeded usage
+  ruleType == "plan_entitlement_usage_exceeded");
+  return {
+    featureUsageExceeded,
+    companyId: companyId == null ? void 0 : companyId,
+    error: error == null ? void 0 : error,
+    featureAllocation: featureAllocation == null ? void 0 : featureAllocation,
+    featureUsage: featureUsage == null ? void 0 : featureUsage,
+    featureUsagePeriod: featureUsagePeriod == null ? void 0 : featureUsagePeriod,
+    featureUsageResetAt: featureUsageResetAt == null ? void 0 : featureUsageResetAt,
+    flag,
+    flagId: flagId == null ? void 0 : flagId,
+    reason,
+    ruleId: ruleId == null ? void 0 : ruleId,
+    ruleType: ruleType == null ? void 0 : ruleType,
+    userId: userId == null ? void 0 : userId,
+    value
+  };
+};
 function contextString(context) {
   const sortedContext = Object.keys(context).reduce((acc, key) => {
     const sortedKeys = Object.keys(
@@ -589,19 +737,18 @@ var Schematic = class {
   context = {};
   eventQueue;
   eventUrl = "https://c.schematichq.com";
-  flagListener;
+  flagCheckListeners = {};
   flagValueListeners = {};
   isPending = true;
   isPendingListeners = /* @__PURE__ */ new Set();
   storage;
   useWebSocket = false;
-  values = {};
+  checks = {};
   webSocketUrl = "wss://api.schematichq.com";
   constructor(apiKey, options) {
     this.apiKey = apiKey;
     this.eventQueue = [];
     this.useWebSocket = options?.useWebSocket ?? false;
-    this.flagListener = options?.flagListener;
     if (options?.additionalHeaders) {
       this.additionalHeaders = options.additionalHeaders;
     }
@@ -625,37 +772,89 @@ var Schematic = class {
       });
     }
   }
-  // Get value for a single flag
-  // If in websocket mode, return the local value, otherwise make an API call
+  /**
+   * Get value for a single flag.
+   * In WebSocket mode, returns cached values if connection is active, otherwise establishes
+   * new connection and then returns the requestedvalue. Falls back to REST API if WebSocket
+   * connection fails.
+   * In REST mode, makes an API call for each check.
+   */
   async checkFlag(options) {
     const { fallback = false, key } = options;
     const context = options.context || this.context;
-    if (this.useWebSocket) {
-      const contextVals = this.values[contextString(context)] ?? {};
-      return typeof contextVals[key] === "undefined" ? fallback : contextVals[key];
+    const contextStr = contextString(context);
+    if (!this.useWebSocket) {
+      const requestUrl = `${this.apiUrl}/flags/${key}/check`;
+      return fetch(requestUrl, {
+        method: "POST",
+        headers: {
+          ...this.additionalHeaders ?? {},
+          "Content-Type": "application/json;charset=UTF-8",
+          "X-Schematic-Api-Key": this.apiKey
+        },
+        body: JSON.stringify(context)
+      }).then((response) => {
+        if (!response.ok) {
+          throw new Error("Network response was not ok");
+        }
+        return response.json();
+      }).then((response) => {
+        return CheckFlagResponseFromJSON(response).data.value;
+      }).catch((error) => {
+        console.error("There was a problem with the fetch operation:", error);
+        return fallback;
+      });
     }
-    const requestUrl = `${this.apiUrl}/flags/${key}/check`;
-    return fetch(requestUrl, {
-      method: "POST",
-      headers: {
-        ...this.additionalHeaders ?? {},
-        "Content-Type": "application/json;charset=UTF-8",
-        "X-Schematic-Api-Key": this.apiKey
-      },
-      body: JSON.stringify(context)
-    }).then((response) => {
+    try {
+      const existingVals = this.checks[contextStr];
+      if (this.conn && typeof existingVals !== "undefined" && typeof existingVals[key] !== "undefined") {
+        return existingVals[key].value;
+      }
+      try {
+        await this.setContext(context);
+      } catch (error) {
+        console.error(
+          "WebSocket connection failed, falling back to REST:",
+          error
+        );
+        return this.fallbackToRest(key, context, fallback);
+      }
+      const contextVals = this.checks[contextStr] ?? {};
+      return contextVals[key]?.value ?? fallback;
+    } catch (error) {
+      console.error("Unexpected error in checkFlag:", error);
+      return fallback;
+    }
+  }
+  /**
+   * Helper method for falling back to REST API when WebSocket connection fails
+   */
+  async fallbackToRest(key, context, fallback) {
+    try {
+      const requestUrl = `${this.apiUrl}/flags/${key}/check`;
+      const response = await fetch(requestUrl, {
+        method: "POST",
+        headers: {
+          ...this.additionalHeaders ?? {},
+          "Content-Type": "application/json;charset=UTF-8",
+          "X-Schematic-Api-Key": this.apiKey
+        },
+        body: JSON.stringify(context)
+      });
       if (!response.ok) {
         throw new Error("Network response was not ok");
       }
-      return response.json();
-    }).then((data) => {
-      return data.data.value;
-    }).catch((error) => {
-      console.error("There was a problem with the fetch operation:", error);
+      const data = CheckFlagResponseFromJSON(await response.json());
+      return data?.data?.value ?? false;
+    } catch (error) {
+      console.error("REST API call failed, using fallback value:", error);
       return fallback;
-    });
+    }
   }
-  // Make an API call to fetch all flag values for a given context (use if not in websocket mode)
+  /**
+   * Make an API call to fetch all flag values for a given context.
+   * Recommended for use in REST mode only.
+   */
   checkFlags = async (context) => {
     context = context || this.context;
     const requestUrl = `${this.apiUrl}/flags/check`;
@@ -673,8 +872,9 @@ var Schematic = class {
         throw new Error("Network response was not ok");
       }
       return response.json();
-    }).then((data) => {
-      return (data?.data?.flags ?? []).reduce(
+    }).then((responseJson) => {
+      const resp = CheckFlagsResponseFromJSON(responseJson);
+      return (resp?.data?.flags ?? []).reduce(
         (accum, flag) => {
           accum[flag.flag] = flag.value;
           return accum;
@@ -683,21 +883,33 @@ var Schematic = class {
       );
     }).catch((error) => {
       console.error("There was a problem with the fetch operation:", error);
-      return false;
+      return {};
     });
   };
-  // Send an identify event
+  /**
+   * Send an identify event.
+   * This will set the context for subsequent flag evaluation and events, and will also
+   * send an identify event to the Schematic API which will upsert a user and company.
+   */
   identify = (body) => {
-    this.setContext({
-      company: body.company?.keys,
-      user: body.keys
-    });
+    try {
+      this.setContext({
+        company: body.company?.keys,
+        user: body.keys
+      });
+    } catch (error) {
+      console.error("Error setting context:", error);
+    }
     return this.handleEvent("identify", body);
   };
-  // Set the flag evaluation context; if the context has changed,
-  // this will open a websocket connection (if not already open)
-  // and submit this context. The promise will resolve when the
-  // websocket sends back an initial set of flag values.
+  /**
+   * Set the flag evaluation context.
+   * In WebSocket mode, this will:
+   * 1. Open a websocket connection if not already open
+   * 2. Send the context to the server
+   * 3. Wait for initial flag values to be returned
+   * The promise resolves when initial flag values are received.
+   */
   setContext = async (context) => {
     if (!this.useWebSocket) {
       this.context = context;
@@ -711,10 +923,14 @@ var Schematic = class {
       const socket = await this.conn;
       await this.wsSendMessage(socket, context);
     } catch (error) {
-      console.error("Error setting Schematic context:", error);
+      console.error("Failed to establish WebSocket connection:", error);
+      throw error;
     }
   };
-  // Send track event
+  /**
+   * Send a track event
+   * Track usage for a company and/or user.
+   */
   track = (body) => {
     const { company, user, event, traits } = body;
     return this.handleEvent("track", {
@@ -786,6 +1002,9 @@ var Schematic = class {
   /**
    * Websocket management
    */
+  /**
+   * If using websocket mode, close the connection when done.
+   */
   cleanup = async () => {
     if (this.conn) {
       try {
@@ -826,18 +1045,15 @@ var Schematic = class {
         let resolved = false;
         const messageHandler = (event) => {
           const message = JSON.parse(event.data);
-          if (!(contextString(context) in this.values)) {
-            this.values[contextString(context)] = {};
-          }
-          (message.flags ?? []).forEach(
-            (flag) => {
-              this.values[contextString(context)][flag.flag] = flag.value;
-              this.notifyFlagValueListeners(flag.flag, flag.value);
-            }
-          );
-          if (this.flagListener) {
-            this.flagListener(this.getFlagValues());
+          if (!(contextString(context) in this.checks)) {
+            this.checks[contextString(context)] = {};
           }
+          (message.flags ?? []).forEach((flag) => {
+            const flagCheck = CheckFlagReturnFromJSON(flag);
+            this.checks[contextString(context)][flagCheck.flag] = flagCheck;
+            this.notifyFlagCheckListeners(flag.flag, flagCheck);
+            this.notifyFlagValueListeners(flag.flag, flagCheck.value);
+          });
           this.setIsPending(false);
           if (!resolved) {
             resolved = true;
@@ -877,18 +1093,21 @@ var Schematic = class {
   setIsPending = (isPending) => {
     this.isPending = isPending;
     this.isPendingListeners.forEach(
-      (listener) => notifyListener(listener, isPending)
+      (listener) => notifyPendingListener(listener, isPending)
     );
   };
+  // flag checks state
+  getFlagCheck = (flagKey) => {
+    const contextStr = contextString(this.context);
+    const checks = this.checks[contextStr] ?? {};
+    return checks[flagKey];
+  };
   // flagValues state
   getFlagValue = (flagKey) => {
-    const values = this.getFlagValues();
-    return values[flagKey];
-  };
-  getFlagValues = () => {
-    const contextStr = contextString(this.context);
-    return this.values[contextStr] ?? {};
+    const check = this.getFlagCheck(flagKey);
+    return check?.value;
   };
+  /** Register an event listener that will be notified with the boolean value for a given flag when this value changes */
   addFlagValueListener = (flagKey, listener) => {
     if (!(flagKey in this.flagValueListeners)) {
       this.flagValueListeners[flagKey] = /* @__PURE__ */ new Set();
@@ -898,12 +1117,40 @@ var Schematic = class {
       this.flagValueListeners[flagKey].delete(listener);
     };
   };
+  /** Register an event listener that will be notified with the full flag check response for a given flag whenever this value changes */
+  addFlagCheckListener = (flagKey, listener) => {
+    if (!(flagKey in this.flagCheckListeners)) {
+      this.flagCheckListeners[flagKey] = /* @__PURE__ */ new Set();
+    }
+    this.flagCheckListeners[flagKey].add(listener);
+    return () => {
+      this.flagCheckListeners[flagKey].delete(listener);
+    };
+  };
+  notifyFlagCheckListeners = (flagKey, check) => {
+    const listeners = this.flagCheckListeners?.[flagKey] ?? [];
+    listeners.forEach((listener) => notifyFlagCheckListener(listener, check));
+  };
   notifyFlagValueListeners = (flagKey, value) => {
     const listeners = this.flagValueListeners?.[flagKey] ?? [];
-    listeners.forEach((listener) => notifyListener(listener, value));
+    listeners.forEach((listener) => notifyFlagValueListener(listener, value));
   };
 };
-var notifyListener = (listener, value) => {
+var notifyPendingListener = (listener, value) => {
+  if (listener.length > 0) {
+    listener(value);
+  } else {
+    listener();
+  }
+};
+var notifyFlagCheckListener = (listener, value) => {
+  if (listener.length > 0) {
+    listener(value);
+  } else {
+    listener();
+  }
+};
+var notifyFlagValueListener = (listener, value) => {
   if (listener.length > 0) {
     listener(value);
   } else {
@@ -912,7 +1159,7 @@ var notifyListener = (listener, value) => {
 };
 
 // src/context/schematic.tsx
-import React, { createContext, useEffect, useMemo } from "react";
+import React, { createContext, useEffect, useMemo, useRef } from "react";
 import { jsx } from "react/jsx-runtime";
 var SchematicContext = createContext(
   null
@@ -923,16 +1170,19 @@ var SchematicProvider = ({
   publishableKey,
   ...clientOpts
 }) => {
+  const initialOptsRef = useRef({
+    publishableKey,
+    useWebSocket: clientOpts.useWebSocket ?? true,
+    ...clientOpts
+  });
   const client = useMemo(() => {
-    const { useWebSocket = true } = clientOpts;
     if (providedClient) {
       return providedClient;
     }
-    return new Schematic(publishableKey, {
-      useWebSocket,
-      ...clientOpts
+    return new Schematic(initialOptsRef.current.publishableKey, {
+      ...initialOptsRef.current
     });
-  }, [providedClient, publishableKey, clientOpts]);
+  }, [providedClient]);
   useEffect(() => {
     return () => {
       if (!providedClient) {
@@ -1004,6 +1254,27 @@ var useSchematicFlag = (key, opts) => {
   }, [client, key, fallback]);
   return useSyncExternalStore(subscribe, getSnapshot);
 };
+var useSchematicFlagCheck = (key, opts) => {
+  const client = useSchematicClient(opts);
+  const fallback = opts?.fallback ?? false;
+  const fallbackCheck = useMemo2(
+    () => ({
+      flag: key,
+      reason: "Fallback",
+      value: fallback
+    }),
+    [key, fallback]
+  );
+  const subscribe = useCallback(
+    (callback) => client.addFlagCheckListener(key, callback),
+    [client, key]
+  );
+  const getSnapshot = useCallback(() => {
+    const check = client.getFlagCheck(key);
+    return check ?? fallbackCheck;
+  }, [client, key, fallbackCheck]);
+  return useSyncExternalStore(subscribe, getSnapshot);
+};
 var useSchematicIsPending = (opts) => {
   const client = useSchematicClient(opts);
   const subscribe = useCallback(
@@ -1014,12 +1285,15 @@ var useSchematicIsPending = (opts) => {
   return useSyncExternalStore(subscribe, getSnapshot);
 };
 export {
+  RuleType,
   Schematic,
   SchematicProvider,
+  UsagePeriod,
   useSchematic,
   useSchematicContext,
   useSchematicEvents,
   useSchematicFlag,
+  useSchematicFlagCheck,
   useSchematicIsPending
 };
 /*! Bundled license information: