@vercel/flags-core 1.6.0 → 1.7.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @vercel/flags-core
 
+## 1.7.1
+
+### Patch Changes
+
+- [#450](https://github.com/vercel/flags/pull/450) [`ceb1519`](https://github.com/vercel/flags/commit/ceb15198f73a973ac559648b8d978c23d23ef0c5) Thanks [@dferber90](https://github.com/dferber90)! - Strip the `g` and `y` flags from RegEx conditions to prevent cached `RegExp` instances from retaining `lastIndex` state.
+
+## 1.7.0
+
+### Minor Changes
+
+- [#427](https://github.com/vercel/flags/pull/427) [`50b1aa4`](https://github.com/vercel/flags/commit/50b1aa4f9614b8e78f76cc9e3ae539e58a46fa7e) Thanks [@dferber90](https://github.com/dferber90)! - Align rollout, split, and segment split user assignment onto a single hash bucketing scheme.
+
+  Previously splits and rollouts bucketed users with opposite conventions, so switching a flag between a split and a rollout (or locking in a rollout as a split) could reassign users even when the effective distribution was unchanged. All three now derive their cut points from one shared boundary function over the full hash space, so a rollout at a given percentage is identical to the equivalent split.
+
+  Split assignments are effectively unchanged. Rollouts and segment splits are re-bucketed once with this release; after that, converting a flag between outcome types never reassigns anyone.
+
 ## 1.6.0
 
 ### Minor Changes

package/dist/{chunk-FBTDSIHP.js → chunk-PLRBLION.js}

@@ -47,21 +47,30 @@ var Packed;
 
 // src/evaluate.ts
 var MAX_REGEX_INPUT_LENGTH = 1e4;
-var UINT32_MAX = 4294967295;
-var scaledWeightsCache = /* @__PURE__ */ new WeakMap();
+var HASH_SPACE = 2 ** 32;
+var PROMILLE_SCALE = 1e5;
+function boundaryFor(numerator, denominator) {
+  return Math.floor(numerator / denominator * HASH_SPACE);
+}
+var splitBoundariesCache = /* @__PURE__ */ new WeakMap();
 var compiledRegexCache = /* @__PURE__ */ new WeakMap();
-function getScaledWeights(outcome) {
-  const cached = scaledWeightsCache.get(outcome);
+function getSplitBoundaries(outcome) {
+  const cached = splitBoundariesCache.get(outcome);
   if (cached) return cached;
   const total = sum(outcome.weights);
-  const scaled = outcome.weights.map((w) => w / total * UINT32_MAX);
-  scaledWeightsCache.set(outcome, scaled);
-  return scaled;
+  const boundaries = [];
+  let cumulative = 0;
+  for (const weight of outcome.weights) {
+    cumulative += weight;
+    boundaries.push(boundaryFor(cumulative, total));
+  }
+  splitBoundariesCache.set(outcome, boundaries);
+  return boundaries;
 }
 function getCompiledRegex(rhs) {
   const cached = compiledRegexCache.get(rhs);
   if (cached) return cached;
-  const compiled = new RegExp(rhs.pattern, rhs.flags);
+  const compiled = new RegExp(rhs.pattern, rhs.flags.replace(/[gy]/, ""));
   compiledRegexCache.set(rhs, compiled);
   return compiled;
 }
@@ -291,11 +300,10 @@ function handleSegmentOutcome(params, outcome) {
     case "split": {
       const lhs = access(outcome.base, params);
       if (typeof lhs !== "string") return false;
-      const maxValue = 1e5;
       if (outcome.passPromille <= 0) return false;
-      if (outcome.passPromille >= maxValue) return true;
-      const value = hashInput(lhs, params.definition.seed) % maxValue;
-      return value < outcome.passPromille;
+      if (outcome.passPromille >= PROMILLE_SCALE) return true;
+      const bucket = hashInput(lhs, params.definition.seed);
+      return bucket < boundaryFor(outcome.passPromille, PROMILLE_SCALE);
     }
     default: {
       const { type } = outcome;
@@ -340,12 +348,18 @@ function handleOutcome(params, outcome) {
           outcomeType: "split" /* SPLIT */
         };
       }
-      const value = hashInput(lhs, params.definition.seed);
-      const scaledWeights = getScaledWeights(outcome);
-      const variantIndex = findWeightedIndex(scaledWeights, value, UINT32_MAX);
-      const variant = variantIndex === -1 ? defaultOutcome : getVariant(params.definition, variantIndex);
+      const bucket = hashInput(lhs, params.definition.seed);
+      const boundaries = getSplitBoundaries(outcome);
+      for (let index = 0; index < boundaries.length; index++) {
+        if (bucket < boundaries[index]) {
+          return {
+            ...getVariant(params.definition, index),
+            outcomeType: "split" /* SPLIT */
+          };
+        }
+      }
       return {
-        ...variant,
+        ...defaultOutcome,
         outcomeType: "split" /* SPLIT */
       };
     }
@@ -381,7 +395,7 @@ function handleOutcome(params, outcome) {
           break;
         }
       }
-      if (exhausted) currentPromille = 1e5;
+      if (exhausted) currentPromille = PROMILLE_SCALE;
       if (currentPromille <= 0) {
         return {
           ...rollFromVariant,
@@ -392,17 +406,26 @@ function handleOutcome(params, outcome) {
         params.definition,
         outcome.rollToVariant
       );
-      if (currentPromille >= 1e5) {
+      if (currentPromille >= PROMILLE_SCALE) {
         return {
           ...rollToVariant,
           outcomeType: "rollout" /* ROLLOUT */
         };
       }
-      const value = hashInput(lhs, params.definition.seed);
-      const threshold = currentPromille / 1e5 * UINT32_MAX;
-      const variant = value < threshold ? rollToVariant : rollFromVariant;
+      const bucket = hashInput(lhs, params.definition.seed);
+      if (outcome.rollToVariant < outcome.rollFromVariant) {
+        const rollToBoundary = boundaryFor(currentPromille, PROMILLE_SCALE);
+        return {
+          ...bucket < rollToBoundary ? rollToVariant : rollFromVariant,
+          outcomeType: "rollout" /* ROLLOUT */
+        };
+      }
+      const rollFromBoundary = boundaryFor(
+        PROMILLE_SCALE - currentPromille,
+        PROMILLE_SCALE
+      );
       return {
-        ...variant,
+        ...bucket < rollFromBoundary ? rollFromVariant : rollToVariant,
         outcomeType: "rollout" /* ROLLOUT */
       };
     }
@@ -483,18 +506,9 @@ function bulkEvaluate(flags, shared) {
   }
   return results;
 }
-function findWeightedIndex(weights, value, maxValue) {
-  if (value < 0 || value >= maxValue) return -1;
-  let sum2 = 0;
-  for (let i = 0; i < weights.length; i++) {
-    sum2 += weights[i];
-    if (value < sum2) return i;
-  }
-  return -1;
-}
 
 // package.json
-var version = "1.6.0";
+var version = "1.7.1";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -971,6 +985,7 @@ var Scheduler = class {
   constructor(onFlush) {
     this.onFlush = onFlush;
   }
+  onFlush;
   resolveWait = null;
   pending = null;
   idleTimeout = null;
@@ -1222,6 +1237,7 @@ var BundledSource = class {
   constructor(options) {
     this.options = options;
   }
+  options;
   promise;
   /**
    * Load bundled definitions.
@@ -2480,4 +2496,4 @@ export {
   resetDefaultFlagsClient,
   createClient
 };
-//# sourceMappingURL=chunk-FBTDSIHP.js.map
+//# sourceMappingURL=chunk-PLRBLION.js.map