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

package/dist/flagmint.umd.js

@@ -38623,6 +38623,12 @@ var __publicField = (obj, key, value) => {
     } 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));
@@ -38661,6 +38667,7 @@ var __publicField = (obj, key, value) => {
   }
   const cacheHelper = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
+    clearCachedFlags,
     clearCachedRulesSnapshot: clearCachedRulesSnapshot$1,
     loadCachedContext: loadCachedContext$1,
     loadCachedFlags: loadCachedFlags$1,
@@ -39095,7 +39102,7 @@ var __publicField = (obj, key, value) => {
       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";
@@ -41875,7 +41882,6 @@ var __publicField = (obj, key, value) => {
   }
   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();
   }
@@ -41903,34 +41909,109 @@ var __publicField = (obj, key, value) => {
     }
     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;
@@ -41940,8 +42021,6 @@ var __publicField = (obj, key, value) => {
         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);
         });
@@ -41961,7 +42040,8 @@ var __publicField = (obj, key, value) => {
       segments: /* @__PURE__ */ new Map(),
       ready: false,
       needsFullConfig: true,
-      piiWire: null
+      piiWire: null,
+      piiWireBroken: false
     };
   }
   function cloneState(state) {
@@ -41976,7 +42056,8 @@ var __publicField = (obj, key, value) => {
         piiAttributes: [...state.piiWire.piiAttributes],
         piiSalt: state.piiWire.piiSalt,
         piiValueEncoding: state.piiWire.piiValueEncoding
-      } : null
+      } : null,
+      piiWireBroken: state.piiWireBroken
     };
   }
   function segmentsFromRecord(record) {
@@ -42003,14 +42084,18 @@ var __publicField = (obj, key, value) => {
       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) {
@@ -42022,15 +42107,20 @@ var __publicField = (obj, key, value) => {
       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()) {
@@ -42050,8 +42140,8 @@ var __publicField = (obj, key, value) => {
             ...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
           }
         };
       }
@@ -42107,8 +42197,8 @@ var __publicField = (obj, key, value) => {
             ...current,
             version: action.toVersion,
             expiresAt: typeof action.expiresAt === "number" ? action.expiresAt : current.expiresAt,
-            ready: true,
-            needsFullConfig: false
+            ready: !current.piiWireBroken,
+            needsFullConfig: current.piiWireBroken
           }
         };
       }
@@ -42131,9 +42221,12 @@ var __publicField = (obj, key, value) => {
       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)
@@ -42217,7 +42310,9 @@ var __publicField = (obj, key, value) => {
           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()) {
@@ -42227,14 +42322,17 @@ var __publicField = (obj, key, value) => {
           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
       };
     }
   }
@@ -42436,7 +42534,7 @@ var __publicField = (obj, key, value) => {
   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)) {
@@ -43205,9 +43303,10 @@ var __publicField = (obj, key, value) => {
         }
         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)
           );
@@ -43449,7 +43548,7 @@ var __publicField = (obj, key, value) => {
      */
     updateFlags(newFlags, fromShare = false) {
       this.flags = newFlags;
-      if (this.enableOfflineCache) {
+      if (this.enableOfflineCache && !this.configSync) {
         void Promise.resolve(
           this.cacheAdapter.saveFlags(this.apiKey, newFlags)
         );