flagmint-js-sdk 2.2.2-rc.0 → 2.2.3-rc.0

package/README.md

@@ -133,7 +133,7 @@ After `ready()`:
 | `transportMode` | `'auto' \| 'sse' \| 'long-polling'` | `'auto'` | `auto` tries SSE, then long-polling |
 | `EventSourceImpl` | EventSource | browser global | Required in Node |
 | `shareConnection` | boolean | `true` in browsers with `BroadcastChannel`, `false` in Node | One stream per API key across same-origin documents |
-| `enableOfflineCache` | boolean | `true` | Load/save flags via the cache adapter |
+| `enableOfflineCache` | boolean | `true` | Server-eval: load/save evaluated flags. Config-sync: load/save **rules** only (evaluated maps are not cached — they are per-user and would collide across tabs). |
 | `persistContext` | boolean | `false` | Persist context in the cache adapter |
 | `cacheAdapter` | CacheAdapter | localStorage helpers | Custom cache (Redis, files, …) |
 | `restEndpoint` | string | env default | Override the long-polling / evaluate URL |
@@ -162,7 +162,7 @@ transportMode: 'long-polling'   // POST evaluate on an interval
 
 # Connection sharing
 
-Used when the same app is embedded twice on one origin (for example two WeSeeDo iframes in a host page).
+Used when the same app is embedded twice on one origin (for example two iframes in a host page).
 
 - **Leader** performs handshake and holds EventSource.
 - **Followers** receive flag snapshots over `BroadcastChannel` (`flagmint-share:<apiKey>`). Leadership is a `localStorage` lock (`flagmint_share_lock:<apiKey>`).

package/dist/flagmint.cjs.js

@@ -38621,6 +38621,12 @@ function saveCachedFlags$1(apiKey, data) {
   } catch {
   }
 }
+function clearCachedFlags(apiKey) {
+  try {
+    storage$1.removeItem?.(getFlagsKey$1(apiKey));
+  } catch {
+  }
+}
 function loadCachedContext$1(apiKey) {
   try {
     const raw = storage$1.getItem(getContextKey$1(apiKey));
@@ -38659,6 +38665,7 @@ function clearCachedRulesSnapshot$1(apiKey) {
 }
 const cacheHelper = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  clearCachedFlags,
   clearCachedRulesSnapshot: clearCachedRulesSnapshot$1,
   loadCachedContext: loadCachedContext$1,
   loadCachedFlags: loadCachedFlags$1,
@@ -39093,7 +39100,7 @@ class SseTransport {
     this.connectPromise = new Promise((resolve, reject) => {
       this.connectResolve = resolve;
       this.connectReject = reject;
-      const sdkVersion = "2.2.2-rc.0";
+      const sdkVersion = "2.2.3-rc.0";
       const platform2 = typeof window !== "undefined" ? "browser" : "nodejs";
       const wrapperName = this.configOptions?.wrapper?.name || "native-js";
       const wrapperVersion = this.configOptions?.wrapper?.version || "none";
@@ -41873,7 +41880,6 @@ function isConfigPayloadExpired(expiresAt, now = Date.now()) {
 }
 const PII_VALUE_ENCODING = "hmac-v1";
 const textEncoder = new TextEncoder();
-const HASH_HEX_PATTERN = /^[0-9a-f]{64}$/;
 function normalizePiiString(value) {
   return value.trim().toLowerCase();
 }
@@ -41901,34 +41907,109 @@ function isPiiAttribute(attribute, piiAttributes) {
   }
   return false;
 }
+function payloadHasExplicitPiiFields(payload) {
+  if (!payload)
+    return false;
+  return payload.piiSalt !== void 0 || payload.piiAttributes !== void 0 || payload.piiValueEncoding !== void 0;
+}
+function piiAttributeKeysFromPayload(payload) {
+  if (!payload || !Array.isArray(payload.piiAttributes))
+    return [];
+  return payload.piiAttributes.filter((k) => typeof k === "string" && k.length > 0);
+}
+function hasMalformedPiiAttributes(payload) {
+  if (!payload || payload.piiAttributes === void 0)
+    return false;
+  if (!Array.isArray(payload.piiAttributes))
+    return true;
+  return payload.piiAttributes.some(
+    (entry) => typeof entry !== "string" || entry.length === 0
+  );
+}
+function hasExplicitInvalidPiiEncoding(payload) {
+  if (!payload || payload.piiValueEncoding === void 0)
+    return false;
+  return payload.piiValueEncoding !== PII_VALUE_ENCODING;
+}
+function payloadRequiresUsablePiiWire(payload) {
+  if (!payload)
+    return false;
+  if (hasExplicitInvalidPiiEncoding(payload))
+    return true;
+  if (hasMalformedPiiAttributes(payload))
+    return true;
+  if (piiAttributeKeysFromPayload(payload).length > 0)
+    return true;
+  return false;
+}
+function isExplicitPiiRequirementCleared(payload) {
+  if (!payload || payload.piiAttributes === void 0)
+    return false;
+  if (!Array.isArray(payload.piiAttributes))
+    return false;
+  if (payload.piiAttributes.length !== 0)
+    return false;
+  if (hasExplicitInvalidPiiEncoding(payload))
+    return false;
+  return true;
+}
 function piiWireOptionsFromPayload(payload) {
   if (!payload)
     return null;
+  if (hasExplicitInvalidPiiEncoding(payload))
+    return null;
+  if (hasMalformedPiiAttributes(payload))
+    return null;
   const salt = typeof payload.piiSalt === "string" ? payload.piiSalt : "";
   if (!salt)
     return null;
-  const encoding = typeof payload.piiValueEncoding === "string" ? payload.piiValueEncoding : PII_VALUE_ENCODING;
-  if (encoding !== PII_VALUE_ENCODING)
-    return null;
-  const attrs = Array.isArray(payload.piiAttributes) ? payload.piiAttributes.filter((k) => typeof k === "string") : [];
+  const attrs = piiAttributeKeysFromPayload(payload);
   return {
     piiAttributes: attrs,
     piiSalt: salt,
     piiValueEncoding: PII_VALUE_ENCODING
   };
 }
-function applyPiiHashToFlatContext(context, options) {
+function isPiiWireBroken(payload, resolved, previousPriorHadPiiAttrs = false) {
+  if (hasExplicitInvalidPiiEncoding(payload) || hasMalformedPiiAttributes(payload)) {
+    return true;
+  }
+  if (resolved) {
+    return false;
+  }
+  if (isExplicitPiiRequirementCleared(payload))
+    return false;
+  if (payloadRequiresUsablePiiWire(payload))
+    return true;
+  if (previousPriorHadPiiAttrs && payloadHasExplicitPiiFields(payload)) {
+    return true;
+  }
+  return false;
+}
+function resolvePiiWireForDelta(previous, action) {
+  if (!payloadHasExplicitPiiFields(action)) {
+    return previous;
+  }
+  const merged = {
+    piiSalt: action.piiSalt !== void 0 ? action.piiSalt : previous?.piiSalt,
+    piiAttributes: action.piiAttributes !== void 0 ? action.piiAttributes : previous?.piiAttributes,
+    piiValueEncoding: action.piiValueEncoding !== void 0 ? action.piiValueEncoding : previous?.piiValueEncoding
+  };
+  return piiWireOptionsFromPayload(merged);
+}
+function applyPiiHashToFlatContext(context, options, mode) {
   if (!options || !options.piiSalt || !options.piiAttributes.length || options.piiValueEncoding !== PII_VALUE_ENCODING) {
     return context;
   }
+  if (mode?.alreadyHashed) {
+    return context;
+  }
   let changed = false;
   const out = { ...context };
   for (const [key2, value] of Object.entries(context)) {
     if (!isPiiAttribute(key2, options.piiAttributes))
       continue;
     if (typeof value === "string") {
-      if (HASH_HEX_PATTERN.test(value))
-        continue;
       out[key2] = hashPiiValue(value, options.piiSalt);
       changed = true;
       continue;
@@ -41938,8 +42019,6 @@ function applyPiiHashToFlatContext(context, options) {
       const next = value.map((entry) => {
         if (typeof entry !== "string")
           return entry;
-        if (HASH_HEX_PATTERN.test(entry))
-          return entry;
         arrayChanged = true;
         return hashPiiValue(entry, options.piiSalt);
       });
@@ -41959,7 +42038,8 @@ function createEmptyRulesState() {
     segments: /* @__PURE__ */ new Map(),
     ready: false,
     needsFullConfig: true,
-    piiWire: null
+    piiWire: null,
+    piiWireBroken: false
   };
 }
 function cloneState(state) {
@@ -41974,7 +42054,8 @@ function cloneState(state) {
       piiAttributes: [...state.piiWire.piiAttributes],
       piiSalt: state.piiWire.piiSalt,
       piiValueEncoding: state.piiWire.piiValueEncoding
-    } : null
+    } : null,
+    piiWireBroken: state.piiWireBroken
   };
 }
 function segmentsFromRecord(record) {
@@ -42001,14 +42082,18 @@ function hydrateFromFull(action) {
     if (flag?.key)
       flags.set(flag.key, flag);
   }
+  const piiWire = piiWireOptionsFromPayload(action);
+  const piiWireBroken = isPiiWireBroken(action, piiWire, false);
   return {
     version: action.version,
     expiresAt: action.expiresAt,
     flags,
     segments: segmentsFromRecord(action.segments),
-    ready: true,
-    needsFullConfig: false,
-    piiWire: piiWireOptionsFromPayload(action)
+    // Usable rules, but PII metadata must be valid when hashing is required.
+    ready: !piiWireBroken,
+    needsFullConfig: piiWireBroken,
+    piiWire,
+    piiWireBroken
   };
 }
 function applyPatch(state, action) {
@@ -42020,15 +42105,20 @@ function applyPatch(state, action) {
     if (flag?.key)
       flags.set(flag.key, flag);
   }
-  const nextPii = piiWireOptionsFromPayload(action) ?? state.piiWire;
+  const nextPii = resolvePiiWireForDelta(state.piiWire, action);
+  const priorHadPiiAttrs = (state.piiWire?.piiAttributes.length ?? 0) > 0 || state.piiWireBroken;
+  const computedBroken = isPiiWireBroken(action, nextPii, priorHadPiiAttrs);
+  const recoveredWithRequiredAttrs = !!nextPii && nextPii.piiAttributes.length > 0;
+  const piiWireBroken = isExplicitPiiRequirementCleared(action) ? false : recoveredWithRequiredAttrs ? false : computedBroken || state.piiWireBroken;
   return {
     version: action.toVersion,
     expiresAt: typeof action.expiresAt === "number" ? action.expiresAt : state.expiresAt,
     flags,
     segments: applySegmentUpserts(state.segments, action.segments),
-    ready: true,
-    needsFullConfig: false,
-    piiWire: nextPii
+    ready: !piiWireBroken,
+    needsFullConfig: piiWireBroken,
+    piiWire: nextPii,
+    piiWireBroken
   };
 }
 function reduceRules(state, action, now = Date.now()) {
@@ -42048,8 +42138,8 @@ function reduceRules(state, action, now = Date.now()) {
           ...cloneState(state),
           version: state.version,
           expiresAt: action.expiresAt,
-          ready: true,
-          needsFullConfig: state.flags.size === 0 || versionMismatch ? true : state.needsFullConfig
+          ready: !state.piiWireBroken,
+          needsFullConfig: state.piiWireBroken || state.flags.size === 0 || versionMismatch ? true : state.needsFullConfig
         }
       };
     }
@@ -42105,8 +42195,8 @@ function reduceRules(state, action, now = Date.now()) {
           ...current,
           version: action.toVersion,
           expiresAt: typeof action.expiresAt === "number" ? action.expiresAt : current.expiresAt,
-          ready: true,
-          needsFullConfig: false
+          ready: !current.piiWireBroken,
+          needsFullConfig: current.piiWireBroken
         }
       };
     }
@@ -42129,9 +42219,12 @@ class RulesStore {
     return this.state;
   }
   /**
-   * Fail-closed readiness: lease not expired and store marked ready.
+   * Fail-closed readiness: lease not expired, store marked ready, and PII
+   * wire metadata usable when hashing is required.
    */
   isReady(now = Date.now()) {
+    if (this.state.piiWireBroken)
+      return false;
     if (!this.state.ready)
       return false;
     if (!this.state.expiresAt)
@@ -42215,7 +42308,9 @@ class RulesStore {
         piiAttributes: [...pii.piiAttributes],
         piiSalt: pii.piiSalt,
         piiValueEncoding: pii.piiValueEncoding
-      } : {}
+      } : {},
+      // Persist fail-closed even when piiWire is null (unusable salt/encoding).
+      ...this.state.piiWireBroken ? { piiWireBroken: true } : {}
     };
   }
   hydrateFromSnapshot(snapshot, now = Date.now()) {
@@ -42225,14 +42320,17 @@ class RulesStore {
         flags.set(flag.key, flag);
     }
     const expired = isConfigPayloadExpired(snapshot.expiresAt, now);
+    const piiWire = piiWireOptionsFromPayload(snapshot);
+    const piiWireBroken = snapshot.piiWireBroken === true || isPiiWireBroken(snapshot, piiWire, false);
     this.state = {
       version: snapshot.version,
       expiresAt: snapshot.expiresAt,
       flags,
       segments: segmentsFromRecord(snapshot.segments),
-      ready: !expired && flags.size > 0,
-      needsFullConfig: expired || flags.size === 0,
-      piiWire: piiWireOptionsFromPayload(snapshot)
+      ready: !expired && flags.size > 0 && !piiWireBroken,
+      needsFullConfig: expired || flags.size === 0 || piiWireBroken,
+      piiWire,
+      piiWireBroken
     };
   }
 }
@@ -42434,7 +42532,7 @@ function flattenEvaluationContext(context) {
 function toComparableString(value) {
   if (value === null || value === void 0)
     return "";
-  return String(value);
+  return String(value).trim().toLowerCase();
 }
 function toComparableArray(value) {
   if (Array.isArray(value)) {
@@ -43203,9 +43301,10 @@ class FlagClient {
       }
       let hydratedRules = false;
       if (this.configSync && this.rulesStore && this.enableOfflineCache) {
+        clearCachedFlags(this.apiKey);
         hydratedRules = await this.hydrateRulesFromCache();
       }
-      if (this.enableOfflineCache && !hydratedRules) {
+      if (this.enableOfflineCache && !this.configSync && !hydratedRules) {
         const cached = await Promise.resolve(
           this.cacheAdapter.loadFlags(this.apiKey, this.cacheTTL)
         );
@@ -43447,7 +43546,7 @@ class FlagClient {
    */
   updateFlags(newFlags, fromShare = false) {
     this.flags = newFlags;
-    if (this.enableOfflineCache) {
+    if (this.enableOfflineCache && !this.configSync) {
       void Promise.resolve(
         this.cacheAdapter.saveFlags(this.apiKey, newFlags)
       );