@vercel/flags-core 1.8.2 → 1.8.3

package/dist/{chunk-ODVYKYSM.cjs → chunk-UX43BKE3.cjs}

@@ -73,7 +73,7 @@ function getSplitBoundaries(outcome) {
 function getCompiledRegex(rhs) {
   const cached = compiledRegexCache.get(rhs);
   if (cached) return cached;
-  const compiled = new RegExp(rhs.pattern, rhs.flags.replace(/[gy]/, ""));
+  const compiled = new RegExp(rhs.pattern, rhs.flags.replace(/[gy]/g, ""));
   compiledRegexCache.set(rhs, compiled);
   return compiled;
 }
@@ -576,7 +576,7 @@ function bulkEvaluate(flags, shared) {
 }
 
 // package.json
-var version = "1.8.2";
+var version = "1.8.3";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -1526,40 +1526,86 @@ var BundledSource = class {
 
 // src/controller/fetch-datafile.ts
 var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DatafileHttpError = class extends Error {
+  constructor(status, statusText) {
+    super(`Failed to fetch data: ${statusText}`);
+    this.status = status;
+  }
+  
+  get retryable() {
+    return this.status === 408 || this.status === 429 || this.status >= 500;
+  }
+};
 async function fetchDatafile(options) {
-  const token = await options.auth.resolveToken();
+  _optionalChain([options, 'access', _44 => _44.signal, 'optionalAccess', _45 => _45.throwIfAborted, 'call', _46 => _46()]);
+  const maxAttempts = _nullishCoalesce(options.maxAttempts, () => ( DEFAULT_MAX_ATTEMPTS));
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new Error("maxAttempts must be a positive integer");
+  }
   const controller = new AbortController();
+  const { signal } = controller;
+  let rejectAbort;
+  const aborted = new Promise((_, reject) => {
+    rejectAbort = reject;
+  });
+  const onAbort = () => rejectAbort(signal.reason);
+  signal.addEventListener("abort", onAbort, { once: true });
+  const onExternalAbort = () => controller.abort(_optionalChain([options, 'access', _47 => _47.signal, 'optionalAccess', _48 => _48.reason]));
+  _optionalChain([options, 'access', _49 => _49.signal, 'optionalAccess', _50 => _50.addEventListener, 'call', _51 => _51("abort", onExternalAbort, { once: true })]);
   const timeoutId = setTimeout(
-    () => controller.abort(),
+    () => controller.abort(
+      new Error("@vercel/flags-core: Datafile fetch deadline exceeded")
+    ),
     DEFAULT_FETCH_TIMEOUT_MS
   );
-  const onExternalAbort = () => controller.abort();
-  if (options.signal) {
-    if (options.signal.aborted) {
-      clearTimeout(timeoutId);
-      throw new Error("Fetch aborted");
-    }
-    options.signal.addEventListener("abort", onExternalAbort, { once: true });
-  }
-  try {
+  let delay;
+  const fetchAttempt = async () => {
+    const token = await options.auth.resolveToken();
+    signal.throwIfAborted();
     const res = await options.fetch(`${options.host}/v1/datafile`, {
       headers: {
         Authorization: `Bearer ${token}`,
         "User-Agent": `VercelFlagsCore/${version}`,
         ...process.env.VERCEL_ENV ? { "X-Vercel-Env": process.env.VERCEL_ENV } : null
       },
-      signal: controller.signal
+      signal
     });
-    clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _44 => _44.signal, 'optionalAccess', _45 => _45.removeEventListener, 'call', _46 => _46("abort", onExternalAbort)]);
+    signal.throwIfAborted();
     if (!res.ok) {
-      throw new Error(`Failed to fetch data: ${res.statusText}`);
+      void _optionalChain([res, 'access', _52 => _52.body, 'optionalAccess', _53 => _53.cancel, 'call', _54 => _54(), 'access', _55 => _55.catch, 'call', _56 => _56(() => {
+      })]);
+      throw new DatafileHttpError(res.status, res.statusText);
     }
-    return res.json();
-  } catch (error) {
+    const data = await res.json();
+    signal.throwIfAborted();
+    return data;
+  };
+  try {
+    for (let attempt = 0; ; attempt++) {
+      if (attempt > 0) {
+        await Promise.race([
+          new Promise((resolve) => {
+            delay = setTimeout(resolve, 100 * 2 ** (attempt - 1));
+          }),
+          aborted
+        ]);
+      }
+      signal.throwIfAborted();
+      try {
+        return await Promise.race([fetchAttempt(), aborted]);
+      } catch (error) {
+        signal.throwIfAborted();
+        if (attempt === maxAttempts - 1 || error instanceof DatafileHttpError && !error.retryable) {
+          throw error instanceof Error ? error : new Error("Unknown fetch error");
+        }
+      }
+    }
+  } finally {
     clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _47 => _47.signal, 'optionalAccess', _48 => _48.removeEventListener, 'call', _49 => _49("abort", onExternalAbort)]);
-    throw error instanceof Error ? error : new Error("Unknown fetch error");
+    clearTimeout(delay);
+    signal.removeEventListener("abort", onAbort);
+    _optionalChain([options, 'access', _57 => _57.signal, 'optionalAccess', _58 => _58.removeEventListener, 'call', _59 => _59("abort", onExternalAbort)]);
   }
 }
 
@@ -1628,7 +1674,7 @@ var TypedEmitter = (_class5 = class {constructor() { _class5.prototype.__init12.
     set.add(handler);
   }
   off(event, handler) {
-    _optionalChain([this, 'access', _50 => _50.handlers, 'access', _51 => _51.get, 'call', _52 => _52(event), 'optionalAccess', _53 => _53.delete, 'call', _54 => _54(handler)]);
+    _optionalChain([this, 'access', _60 => _60.handlers, 'access', _61 => _61.get, 'call', _62 => _62(event), 'optionalAccess', _63 => _63.delete, 'call', _64 => _64(handler)]);
   }
   emit(event, ...args) {
     const set = this.handlers.get(event);
@@ -1654,14 +1700,17 @@ var PollingSource = class extends TypedEmitter {
    * Emits 'data' on success, 'error' on failure.
    */
   async poll() {
-    if (_optionalChain([this, 'access', _55 => _55.abortController, 'optionalAccess', _56 => _56.signal, 'access', _57 => _57.aborted])) return;
+    if (_optionalChain([this, 'access', _65 => _65.abortController, 'optionalAccess', _66 => _66.signal, 'access', _67 => _67.aborted])) return;
+    this.abortController ??= new AbortController();
+    const controller = this.abortController;
     try {
       const data = await fetchDatafile({
         ...this.config,
-        signal: _optionalChain([this, 'access', _58 => _58.abortController, 'optionalAccess', _59 => _59.signal])
+        signal: controller.signal
       });
       this.emit("data", data);
     } catch (error) {
+      controller.signal.throwIfAborted();
       const err = error instanceof Error ? error : new Error("Unknown poll error");
       this.emit("error", err);
     }
@@ -1673,9 +1722,9 @@ var PollingSource = class extends TypedEmitter {
    */
   startInterval() {
     if (this.intervalId) return;
-    this.abortController = new AbortController();
     this.intervalId = setInterval(
-      () => void this.poll(),
+      () => void this.poll().catch(() => {
+      }),
       this.config.polling.intervalMs
     );
   }
@@ -1687,7 +1736,7 @@ var PollingSource = class extends TypedEmitter {
       clearInterval(this.intervalId);
       this.intervalId = void 0;
     }
-    _optionalChain([this, 'access', _60 => _60.abortController, 'optionalAccess', _61 => _61.abort, 'call', _62 => _62()]);
+    _optionalChain([this, 'access', _68 => _68.abortController, 'optionalAccess', _69 => _69.abort, 'call', _70 => _70()]);
     this.abortController = void 0;
   }
 };
@@ -1766,7 +1815,7 @@ async function connectStream(config, callbacks) {
         if (pingTimeoutId !== void 0) clearTimeout(pingTimeoutId);
         if (!initialDataReceived) return;
         pingTimeoutId = setTimeout(() => {
-          _optionalChain([responseBody, 'optionalAccess', _63 => _63.cancel, 'call', _64 => _64(), 'access', _65 => _65.catch, 'call', _66 => _66(() => {
+          _optionalChain([responseBody, 'optionalAccess', _71 => _71.cancel, 'call', _72 => _72(), 'access', _73 => _73.catch, 'call', _74 => _74(() => {
           })]);
           connectionAbort.abort();
         }, PING_TIMEOUT_MS);
@@ -1788,7 +1837,7 @@ async function connectStream(config, callbacks) {
         if (vercelEnv) {
           headers["X-Vercel-Env"] = vercelEnv;
         }
-        const revision = _optionalChain([config, 'access', _67 => _67.revision, 'optionalCall', _68 => _68()]);
+        const revision = _optionalChain([config, 'access', _75 => _75.revision, 'optionalCall', _76 => _76()]);
         if (revision !== void 0) {
           headers["X-Revision"] = String(revision);
         }
@@ -1850,7 +1899,7 @@ async function connectStream(config, callbacks) {
                 resetPingTimeout();
               }
               if (message.type === "primed") {
-                _optionalChain([onPrimed, 'optionalCall', _69 => _69(message)]);
+                _optionalChain([onPrimed, 'optionalCall', _77 => _77(message)]);
                 retryCount = 0;
                 if (!initialDataReceived) {
                   initialDataReceived = true;
@@ -1873,7 +1922,7 @@ async function connectStream(config, callbacks) {
         clearTimeout(pingTimeoutId);
         abortController.signal.removeEventListener("abort", onMainAbort);
         if (!abortController.signal.aborted) {
-          _optionalChain([onDisconnect, 'optionalCall', _70 => _70()]);
+          _optionalChain([onDisconnect, 'optionalCall', _78 => _78()]);
           retryCount++;
           const elapsed = Date.now() - lastAttemptTime;
           const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1894,7 +1943,7 @@ async function connectStream(config, callbacks) {
         if (!connectionAbort.signal.aborted) {
           lastError = error;
         }
-        _optionalChain([onDisconnect, 'optionalCall', _71 => _71()]);
+        _optionalChain([onDisconnect, 'optionalCall', _79 => _79()]);
         retryCount++;
         const elapsed = Date.now() - lastAttemptTime;
         const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1973,7 +2022,7 @@ var StreamSource = class extends TypedEmitter {
    * Stop the stream connection.
    */
   stop() {
-    _optionalChain([this, 'access', _72 => _72.abortController, 'optionalAccess', _73 => _73.abort, 'call', _74 => _74()]);
+    _optionalChain([this, 'access', _80 => _80.abortController, 'optionalAccess', _81 => _81.abort, 'call', _82 => _82()]);
     this.abortController = void 0;
     this.promise = void 0;
   }
@@ -2032,7 +2081,7 @@ var Controller = (_class6 = class {
     this.options = normalizeOptions(options);
     this.streamSource = new StreamSource(
       this.options,
-      () => _optionalChain([this, 'access', _75 => _75.data, 'optionalAccess', _76 => _76.revision])
+      () => _optionalChain([this, 'access', _83 => _83.data, 'optionalAccess', _84 => _84.revision])
     );
     this.pollingSource = new PollingSource(this.options);
     this.bundledSource = new BundledSource({
@@ -2574,11 +2623,11 @@ var Controller = (_class6 = class {
       duration: Date.now() - startTime,
       mode: mode === "streaming" ? "stream" : mode === "polling" ? "poll" : mode
     };
-    const configUpdatedAt = _optionalChain([this, 'access', _77 => _77.data, 'optionalAccess', _78 => _78.configUpdatedAt]);
+    const configUpdatedAt = _optionalChain([this, 'access', _85 => _85.data, 'optionalAccess', _86 => _86.configUpdatedAt]);
     if (typeof configUpdatedAt === "number") {
       trackOptions.configUpdatedAt = configUpdatedAt;
     }
-    const revision = _optionalChain([this, 'access', _79 => _79.data, 'optionalAccess', _80 => _80.revision]);
+    const revision = _optionalChain([this, 'access', _87 => _87.data, 'optionalAccess', _88 => _88.revision]);
     if (typeof revision === "number") {
       trackOptions.revision = revision;
     }
@@ -2750,4 +2799,4 @@ var {
 
 
 exports.ResolutionReason = ResolutionReason; exports.evaluate = evaluate; exports.FallbackNotFoundError = FallbackNotFoundError; exports.FallbackEntryNotFoundError = FallbackEntryNotFoundError; exports.Controller = Controller; exports.flagsClient = flagsClient; exports.resetDefaultFlagsClient = resetDefaultFlagsClient; exports.createClient = createClient;
-//# sourceMappingURL=chunk-ODVYKYSM.cjs.map
+//# sourceMappingURL=chunk-UX43BKE3.cjs.map