@uniformdev/canvas-next-rsc-client 19.61.1-alpha.23 → 19.62.1-alpha.127

package/dist/index.mjs

@@ -1,31 +1,240 @@
 "use client";
-
-// src/components/ClientContextualEditingComponentWrapper.tsx
-import { IN_CONTEXT_EDITOR_QUERY_STRING_PARAM } from "@uniformdev/canvas";
-import {
-  PureContextualEditingComponentWrapper
-} from "@uniformdev/canvas-react/core";
-import { useSearchParams } from "next/navigation";
-import { Suspense } from "react";
-import { Fragment, jsx } from "react/jsx-runtime";
-var ClientContextualEditingComponentWrapper = (props) => {
-  return /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(ClientContextualEditingComponentWrapperInner, { ...props }) });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var ClientContextualEditingComponentWrapperInner = ({
-  children,
-  ...rest
-}) => {
-  const searchParams = useSearchParams();
-  const inContextMode = searchParams.get(IN_CONTEXT_EDITOR_QUERY_STRING_PARAM) === "true";
-  if (!inContextMode) {
-    return /* @__PURE__ */ jsx(Fragment, { children });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return /* @__PURE__ */ jsx(PureContextualEditingComponentWrapper, { ...rest, children });
+  return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
-// src/components/ClientContextUpdate.tsx
-import { useParams, useSearchParams as useSearchParams2 } from "next/navigation";
-import { Suspense as Suspense2, useEffect as useEffect2 } from "react";
+// ../../node_modules/.pnpm/rfdc@1.3.1/node_modules/rfdc/index.js
+var require_rfdc = __commonJS({
+  "../../node_modules/.pnpm/rfdc@1.3.1/node_modules/rfdc/index.js"(exports, module) {
+    "use strict";
+    module.exports = rfdc4;
+    function copyBuffer(cur) {
+      if (cur instanceof Buffer) {
+        return Buffer.from(cur);
+      }
+      return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+    }
+    function rfdc4(opts) {
+      opts = opts || {};
+      if (opts.circles)
+        return rfdcCircles(opts);
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a, fn) {
+        var keys = Object.keys(a);
+        var a2 = new Array(keys.length);
+        for (var i = 0; i < keys.length; i++) {
+          var k = keys[i];
+          var cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur instanceof Date) {
+            a2[k] = new Date(cur);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            a2[k] = fn(cur);
+          }
+        }
+        return a2;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null)
+          return o;
+        if (o instanceof Date)
+          return new Date(o);
+        if (Array.isArray(o))
+          return cloneArray(o, clone2);
+        if (o instanceof Map)
+          return new Map(cloneArray(Array.from(o), clone2));
+        if (o instanceof Set)
+          return new Set(cloneArray(Array.from(o), clone2));
+        var o2 = {};
+        for (var k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false)
+            continue;
+          var cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur instanceof Date) {
+            o2[k] = new Date(cur);
+          } else if (cur instanceof Map) {
+            o2[k] = new Map(cloneArray(Array.from(cur), clone2));
+          } else if (cur instanceof Set) {
+            o2[k] = new Set(cloneArray(Array.from(cur), clone2));
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = clone2(cur);
+          }
+        }
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null)
+          return o;
+        if (o instanceof Date)
+          return new Date(o);
+        if (Array.isArray(o))
+          return cloneArray(o, cloneProto);
+        if (o instanceof Map)
+          return new Map(cloneArray(Array.from(o), cloneProto));
+        if (o instanceof Set)
+          return new Set(cloneArray(Array.from(o), cloneProto));
+        var o2 = {};
+        for (var k in o) {
+          var cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur instanceof Date) {
+            o2[k] = new Date(cur);
+          } else if (cur instanceof Map) {
+            o2[k] = new Map(cloneArray(Array.from(cur), cloneProto));
+          } else if (cur instanceof Set) {
+            o2[k] = new Set(cloneArray(Array.from(cur), cloneProto));
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            o2[k] = cloneProto(cur);
+          }
+        }
+        return o2;
+      }
+    }
+    function rfdcCircles(opts) {
+      var refs = [];
+      var refsNew = [];
+      return opts.proto ? cloneProto : clone2;
+      function cloneArray(a, fn) {
+        var keys = Object.keys(a);
+        var a2 = new Array(keys.length);
+        for (var i = 0; i < keys.length; i++) {
+          var k = keys[i];
+          var cur = a[k];
+          if (typeof cur !== "object" || cur === null) {
+            a2[k] = cur;
+          } else if (cur instanceof Date) {
+            a2[k] = new Date(cur);
+          } else if (ArrayBuffer.isView(cur)) {
+            a2[k] = copyBuffer(cur);
+          } else {
+            var index = refs.indexOf(cur);
+            if (index !== -1) {
+              a2[k] = refsNew[index];
+            } else {
+              a2[k] = fn(cur);
+            }
+          }
+        }
+        return a2;
+      }
+      function clone2(o) {
+        if (typeof o !== "object" || o === null)
+          return o;
+        if (o instanceof Date)
+          return new Date(o);
+        if (Array.isArray(o))
+          return cloneArray(o, clone2);
+        if (o instanceof Map)
+          return new Map(cloneArray(Array.from(o), clone2));
+        if (o instanceof Set)
+          return new Set(cloneArray(Array.from(o), clone2));
+        var o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (var k in o) {
+          if (Object.hasOwnProperty.call(o, k) === false)
+            continue;
+          var cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur instanceof Date) {
+            o2[k] = new Date(cur);
+          } else if (cur instanceof Map) {
+            o2[k] = new Map(cloneArray(Array.from(cur), clone2));
+          } else if (cur instanceof Set) {
+            o2[k] = new Set(cloneArray(Array.from(cur), clone2));
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            var i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = clone2(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+      function cloneProto(o) {
+        if (typeof o !== "object" || o === null)
+          return o;
+        if (o instanceof Date)
+          return new Date(o);
+        if (Array.isArray(o))
+          return cloneArray(o, cloneProto);
+        if (o instanceof Map)
+          return new Map(cloneArray(Array.from(o), cloneProto));
+        if (o instanceof Set)
+          return new Set(cloneArray(Array.from(o), cloneProto));
+        var o2 = {};
+        refs.push(o);
+        refsNew.push(o2);
+        for (var k in o) {
+          var cur = o[k];
+          if (typeof cur !== "object" || cur === null) {
+            o2[k] = cur;
+          } else if (cur instanceof Date) {
+            o2[k] = new Date(cur);
+          } else if (cur instanceof Map) {
+            o2[k] = new Map(cloneArray(Array.from(cur), cloneProto));
+          } else if (cur instanceof Set) {
+            o2[k] = new Set(cloneArray(Array.from(cur), cloneProto));
+          } else if (ArrayBuffer.isView(cur)) {
+            o2[k] = copyBuffer(cur);
+          } else {
+            var i = refs.indexOf(cur);
+            if (i !== -1) {
+              o2[k] = refsNew[i];
+            } else {
+              o2[k] = cloneProto(cur);
+            }
+          }
+        }
+        refs.pop();
+        refsNew.pop();
+        return o2;
+      }
+    }
+  }
+});
+
+// src/components/ClientContextPersonalizationTransfer.tsx
+import { useEffect as useEffect2, useState as useState2 } from "react";
 
 // src/hooks/useUniformContext.ts
 import { useEffect, useState } from "react";
@@ -47,37 +256,97 @@ var useUniformContext = () => {
   };
 };
 
+// src/components/ClientContextPersonalizationTransfer.tsx
+var ClientContextPersonalizationTransfer = ({
+  event,
+  ts
+}) => {
+  const { context } = useUniformContext();
+  const [lastLogged, setLastLogged] = useState2(void 0);
+  useEffect2(() => {
+    const shouldBeLogged = !ts || lastLogged !== ts;
+    const hasContext = typeof context !== "undefined";
+    if (shouldBeLogged && hasContext) {
+      setLastLogged(ts);
+      context.internal_processPersonalizationEvent(event);
+    }
+  }, [context, event, lastLogged, ts]);
+  return null;
+};
+
+// src/components/ClientContextTestTransfer.tsx
+import { useEffect as useEffect3, useState as useState3 } from "react";
+var ClientContextTestTransfer = ({ event, ts }) => {
+  const { context } = useUniformContext();
+  const [lastLogged, setLastLogged] = useState3(void 0);
+  useEffect3(() => {
+    const shouldBeLogged = !ts || lastLogged !== ts;
+    const hasContext = typeof context !== "undefined";
+    if (shouldBeLogged && hasContext && event.variantId) {
+      setLastLogged(ts);
+      context.internal_processTestEvent(event);
+    }
+  }, [context, event, lastLogged, ts]);
+  return null;
+};
+
+// src/components/ClientContextualEditingComponentWrapper.tsx
+import { IN_CONTEXT_EDITOR_QUERY_STRING_PARAM } from "@uniformdev/canvas";
+import {
+  PureContextualEditingComponentWrapper
+} from "@uniformdev/canvas-react/core";
+import { useSearchParams } from "next/navigation";
+import { Suspense } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var ClientContextualEditingComponentWrapper = (props) => {
+  return /* @__PURE__ */ jsx(Suspense, { children: /* @__PURE__ */ jsx(ClientContextualEditingComponentWrapperInner, { ...props }) });
+};
+var ClientContextualEditingComponentWrapperInner = ({
+  children,
+  ...rest
+}) => {
+  const searchParams = useSearchParams();
+  const inContextMode = searchParams.get(IN_CONTEXT_EDITOR_QUERY_STRING_PARAM) === "true";
+  if (!inContextMode) {
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return /* @__PURE__ */ jsx(PureContextualEditingComponentWrapper, { ...rest, children });
+};
+
 // src/components/ClientContextUpdate.tsx
+import { useSearchParams as useSearchParams2 } from "next/navigation";
+import { Suspense as Suspense2, useEffect as useEffect4 } from "react";
 import { Fragment as Fragment2, jsx as jsx2 } from "react/jsx-runtime";
-var ClientContextUpdate = () => {
-  return /* @__PURE__ */ jsx2(Suspense2, { children: /* @__PURE__ */ jsx2(ClientContextUpdateInner, {}) });
+var ClientContextUpdate = ({ path }) => {
+  return /* @__PURE__ */ jsx2(Suspense2, { children: /* @__PURE__ */ jsx2(ClientContextUpdateInner, { path }) });
 };
-var ClientContextUpdateInner = () => {
-  const params = useParams();
+var ClientContextUpdateInner = ({ path }) => {
   const searchParams = useSearchParams2();
   const { context } = useUniformContext();
-  useEffect2(() => {
+  useEffect4(() => {
     if (!context || typeof window === "undefined") {
       return;
     }
     const convertedSearchParams = Object.fromEntries(searchParams.entries());
     context.update({
-      params,
+      params: {
+        path: path.split("/").filter(Boolean)
+      },
       searchParams: convertedSearchParams
     });
-  }, [params, searchParams, context]);
+  }, [path, searchParams, context]);
   return /* @__PURE__ */ jsx2(Fragment2, {});
 };
 
 // src/components/ContextUpdateTransferClient.tsx
-import { useEffect as useEffect3, useState as useState2 } from "react";
+import { useEffect as useEffect5, useState as useState4 } from "react";
 var ContextUpdateTransferClient = ({
   update,
   ts
 }) => {
   const { context } = useUniformContext();
-  const [lastLogged, setLastLogged] = useState2(void 0);
-  useEffect3(() => {
+  const [lastLogged, setLastLogged] = useState4(void 0);
+  useEffect5(() => {
     const shouldBeLogged = (!ts || lastLogged !== ts) && Object.keys(update).length > 0;
     const hasContext = typeof context !== "undefined";
     if (shouldBeLogged && hasContext) {
@@ -88,6 +357,548 @@ var ContextUpdateTransferClient = ({
   return null;
 };
 
+// ../../node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/lite/index.mjs
+var has = Object.prototype.hasOwnProperty;
+function dequal(foo, bar) {
+  var ctor, len;
+  if (foo === bar)
+    return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date)
+      return foo.getTime() === bar.getTime();
+    if (ctor === RegExp)
+      return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && dequal(foo[len], bar[len]))
+          ;
+      }
+      return len === -1;
+    }
+    if (!ctor || typeof foo === "object") {
+      len = 0;
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor))
+          return false;
+        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor]))
+          return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
+
+// ../../node_modules/.pnpm/js-cookie@3.0.5/node_modules/js-cookie/dist/js.cookie.mjs
+function assign(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i];
+    for (var key in source) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+var defaultConverter = {
+  read: function(value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+  },
+  write: function(value) {
+    return encodeURIComponent(value).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    );
+  }
+};
+function init(converter, defaultAttributes) {
+  function set(name, value, attributes) {
+    if (typeof document === "undefined") {
+      return;
+    }
+    attributes = assign({}, defaultAttributes, attributes);
+    if (typeof attributes.expires === "number") {
+      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);
+    }
+    if (attributes.expires) {
+      attributes.expires = attributes.expires.toUTCString();
+    }
+    name = encodeURIComponent(name).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+    var stringifiedAttributes = "";
+    for (var attributeName in attributes) {
+      if (!attributes[attributeName]) {
+        continue;
+      }
+      stringifiedAttributes += "; " + attributeName;
+      if (attributes[attributeName] === true) {
+        continue;
+      }
+      stringifiedAttributes += "=" + attributes[attributeName].split(";")[0];
+    }
+    return document.cookie = name + "=" + converter.write(value, name) + stringifiedAttributes;
+  }
+  function get(name) {
+    if (typeof document === "undefined" || arguments.length && !name) {
+      return;
+    }
+    var cookies = document.cookie ? document.cookie.split("; ") : [];
+    var jar = {};
+    for (var i = 0; i < cookies.length; i++) {
+      var parts = cookies[i].split("=");
+      var value = parts.slice(1).join("=");
+      try {
+        var found = decodeURIComponent(parts[0]);
+        jar[found] = converter.read(value, found);
+        if (name === found) {
+          break;
+        }
+      } catch (e) {
+      }
+    }
+    return name ? jar[name] : jar;
+  }
+  return Object.create(
+    {
+      set,
+      get,
+      remove: function(name, attributes) {
+        set(
+          name,
+          "",
+          assign({}, attributes, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function(attributes) {
+        return init(this.converter, assign({}, this.attributes, attributes));
+      },
+      withConverter: function(converter2) {
+        return init(assign({}, this.converter, converter2), this.attributes);
+      }
+    },
+    {
+      attributes: { value: Object.freeze(defaultAttributes) },
+      converter: { value: Object.freeze(converter) }
+    }
+  );
+}
+var api = init(defaultConverter, { path: "/" });
+
+// ../context/dist/index.mjs
+var import_rfdc = __toESM(require_rfdc(), 1);
+var import_rfdc2 = __toESM(require_rfdc(), 1);
+var import_rfdc3 = __toESM(require_rfdc(), 1);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var ENR_SEPARATOR = "_";
+var _evaluator;
+var _onLogMessage;
+_evaluator = /* @__PURE__ */ new WeakMap();
+_onLogMessage = /* @__PURE__ */ new WeakMap();
+var _mf;
+var _signalInstances;
+var _onLogMessage2;
+_mf = /* @__PURE__ */ new WeakMap();
+_signalInstances = /* @__PURE__ */ new WeakMap();
+_onLogMessage2 = /* @__PURE__ */ new WeakMap();
+function getEnrichmentVectorKey(category, value) {
+  return `${category}${ENR_SEPARATOR}${value}`;
+}
+function isNumberMatch(lhs, match) {
+  var _a;
+  if (typeof lhs === "undefined" || lhs === null) {
+    return false;
+  }
+  const lhsValue = Number(lhs);
+  if (isNaN(lhsValue)) {
+    return false;
+  }
+  switch ((_a = match == null ? void 0 : match.op) != null ? _a : "=") {
+    case "=":
+      return lhsValue === match.rhs;
+    case "!=":
+      return lhsValue !== match.rhs;
+    case ">":
+      return lhsValue > match.rhs;
+    case "<":
+      return lhsValue < match.rhs;
+    default:
+      console.warn(`Unknown match type ${match.op} is false.`);
+      return false;
+  }
+}
+function explainNumberMatch(lhs, match) {
+  return `${lhs} ${explainNumberMatchCriteria(match)}`;
+}
+function explainNumberMatchCriteria(match) {
+  return `${match.op} ${match.rhs}`;
+}
+var pageViewCountDimension = getEnrichmentVectorKey("$pvc", "v");
+var pageViewCountEvaluator = ({ update, criteria, commands, onLogMessage }) => {
+  var _a, _b;
+  if (criteria.type !== "PVC") {
+    return { result: false, changed: false };
+  }
+  const hasUrlChanged = Boolean(
+    update.state.url && (!update.previousState || ((_a = update.state.url) == null ? void 0 : _a.toString()) !== ((_b = update.previousState.url) == null ? void 0 : _b.toString()))
+  );
+  const existingValueNumber = update.visitor.sessionScores[pageViewCountDimension] || 0;
+  const updatedCount = existingValueNumber + 1;
+  const finalResult = { result: false, changed: hasUrlChanged };
+  const hasExistingPageViewIncrementCommand = commands.some(
+    (c) => c.type === "modscoreS" && c.data.dimension === pageViewCountDimension
+  );
+  if (hasUrlChanged && !hasExistingPageViewIncrementCommand) {
+    commands.push({
+      type: "modscoreS",
+      data: {
+        dimension: pageViewCountDimension,
+        delta: 1
+      }
+    });
+  }
+  if (isNumberMatch(updatedCount, criteria.match)) {
+    finalResult.result = true;
+  }
+  onLogMessage == null ? void 0 : onLogMessage([
+    "debug",
+    203,
+    { criteria, result: finalResult, explanation: explainNumberMatch(updatedCount, criteria.match) }
+  ]);
+  return finalResult;
+};
+pageViewCountEvaluator.alwaysExecute = true;
+var _evaluators;
+_evaluators = /* @__PURE__ */ new WeakMap();
+var _data;
+var _initialData;
+var _mitt;
+_data = /* @__PURE__ */ new WeakMap();
+_initialData = /* @__PURE__ */ new WeakMap();
+_mitt = /* @__PURE__ */ new WeakMap();
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var b2s = alphabet.split("");
+var s2b = new Array(123);
+for (let i = 0; i < alphabet.length; i++) {
+  s2b[alphabet.charCodeAt(i)] = i;
+}
+var _cookieName;
+var _cookieAttributes;
+_cookieName = /* @__PURE__ */ new WeakMap();
+_cookieAttributes = /* @__PURE__ */ new WeakMap();
+var _fetchData;
+var fetchData_fn;
+_fetchData = /* @__PURE__ */ new WeakSet();
+fetchData_fn = async function() {
+  const serviceData = await new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(void 0);
+    }, 2e3);
+  });
+  if (serviceData) {
+    this.signalAsyncDataUpdate(serviceData);
+  }
+};
+var emptyVisitorData = () => ({
+  quirks: {},
+  scores: {},
+  sessionScores: {},
+  tests: {},
+  consent: false,
+  controlGroup: false,
+  personalizeVariants: {}
+});
+var clone = (0, import_rfdc.default)();
+var STORAGE_KEY = "ufvisitor";
+var _mitt2;
+var _persist;
+var _visitTimeout;
+var _options;
+var _currentData;
+var currentData_get;
+var _replaceData;
+var replaceData_fn;
+var _setVisitTimeout;
+var setVisitTimeout_fn;
+var _isExpired;
+var isExpired_fn;
+var _handleCaps;
+var handleCaps_fn;
+var _defaultData;
+var defaultData_fn;
+_mitt2 = /* @__PURE__ */ new WeakMap();
+_persist = /* @__PURE__ */ new WeakMap();
+_visitTimeout = /* @__PURE__ */ new WeakMap();
+_options = /* @__PURE__ */ new WeakMap();
+_currentData = /* @__PURE__ */ new WeakSet();
+currentData_get = function() {
+  return __privateGet(this, _persist).get(STORAGE_KEY);
+};
+_replaceData = /* @__PURE__ */ new WeakSet();
+replaceData_fn = function(data, quiet = false) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const oldData = __privateGet(this, _currentData, currentData_get);
+  const now = Date.now();
+  if (data.controlGroup) {
+    data.scores = {};
+    data.sessionScores = {};
+  } else {
+    __privateMethod(this, _handleCaps, handleCaps_fn).call(this, data.scores);
+    __privateMethod(this, _handleCaps, handleCaps_fn).call(this, data.sessionScores);
+    (_b = (_a = __privateGet(this, _options)).decay) == null ? void 0 : _b.call(_a, {
+      now,
+      lastUpd: oldData == null ? void 0 : oldData.updated,
+      scores: data.scores,
+      sessionScores: data.sessionScores,
+      onLogMessage: __privateGet(this, _options).onLogMessage
+    });
+  }
+  const haveScoresChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.scores, data.scores);
+  const haveSessionScoresChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.sessionScores, data.sessionScores);
+  const haveQuirksChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.quirks, data.quirks);
+  const haveTestsChanged = !dequal(oldData == null ? void 0 : oldData.visitorData.tests, data.tests);
+  const updatedData = {
+    updated: now,
+    visitorData: data
+  };
+  __privateMethod(this, _setVisitTimeout, setVisitTimeout_fn).call(this);
+  __privateGet(this, _persist).set(STORAGE_KEY, updatedData, !!data.consent);
+  (_d = (_c = __privateGet(this, _options)).onLogMessage) == null ? void 0 : _d.call(_c, ["debug", 102, data]);
+  if (!quiet) {
+    if (haveScoresChanged || haveSessionScoresChanged) {
+      __privateGet(this, _mitt2).emit("scoresUpdated", data);
+    }
+    if (haveQuirksChanged) {
+      __privateGet(this, _mitt2).emit("quirksUpdated", data);
+    }
+    if (haveTestsChanged) {
+      __privateGet(this, _mitt2).emit("testsUpdated", data);
+    }
+    if (((_e = oldData == null ? void 0 : oldData.visitorData) == null ? void 0 : _e.consent) !== data.consent) {
+      __privateGet(this, _mitt2).emit("consentUpdated", data);
+    }
+    if (((_f = oldData == null ? void 0 : oldData.visitorData) == null ? void 0 : _f.controlGroup) !== data.controlGroup) {
+      __privateGet(this, _mitt2).emit("controlGroupUpdated", data);
+      (_i = (_h = __privateGet(this, _options)).onLogMessage) == null ? void 0 : _i.call(_h, ["debug", 104, (_g = data.controlGroup) != null ? _g : false]);
+    }
+  }
+};
+_setVisitTimeout = /* @__PURE__ */ new WeakSet();
+setVisitTimeout_fn = function() {
+  if (typeof document === "undefined" || !__privateGet(this, _options).visitLifespan) {
+    return;
+  }
+  if (__privateGet(this, _visitTimeout)) {
+    window.clearTimeout(__privateGet(this, _visitTimeout));
+  }
+  __privateSet(this, _visitTimeout, window.setTimeout(() => {
+    this.data;
+  }, __privateGet(this, _options).visitLifespan + 50));
+};
+_isExpired = /* @__PURE__ */ new WeakSet();
+isExpired_fn = function(data) {
+  const expires = __privateGet(this, _options).visitLifespan;
+  return expires ? data.updated + expires < Date.now() : false;
+};
+_handleCaps = /* @__PURE__ */ new WeakSet();
+handleCaps_fn = function(scores) {
+  var _a, _b;
+  if (!__privateGet(this, _options).manifest) {
+    return;
+  }
+  for (const dim in scores) {
+    const score = scores[dim];
+    const dimDef = __privateGet(this, _options).manifest.getDimensionByKey(dim);
+    if (!dimDef) {
+      continue;
+    }
+    if (score > dimDef.cap) {
+      (_b = (_a = __privateGet(this, _options)).onLogMessage) == null ? void 0 : _b.call(_a, ["debug", 110, { dim, score, cap: dimDef.cap }]);
+      scores[dim] = dimDef.cap;
+    }
+  }
+};
+_defaultData = /* @__PURE__ */ new WeakSet();
+defaultData_fn = function() {
+  var _a, _b, _c;
+  return {
+    ...emptyVisitorData(),
+    consent: (_a = __privateGet(this, _options).defaultConsent) != null ? _a : false,
+    controlGroup: (_c = (_b = __privateGet(this, _options).manifest) == null ? void 0 : _b.rollForControlGroup()) != null ? _c : false
+  };
+};
+var _serverTransitionState;
+var _scores;
+var _state;
+var _pzCache;
+var _mitt3;
+var _emitTest;
+var emitTest_fn;
+var _updateComputedScores;
+var updateComputedScores_fn;
+var _calculateScores;
+var calculateScores_fn;
+_serverTransitionState = /* @__PURE__ */ new WeakMap();
+_scores = /* @__PURE__ */ new WeakMap();
+_state = /* @__PURE__ */ new WeakMap();
+_pzCache = /* @__PURE__ */ new WeakMap();
+_mitt3 = /* @__PURE__ */ new WeakMap();
+_emitTest = /* @__PURE__ */ new WeakSet();
+emitTest_fn = function(event) {
+  __privateGet(this, _mitt3).emit("testResult", event);
+};
+_updateComputedScores = /* @__PURE__ */ new WeakSet();
+updateComputedScores_fn = function(newData) {
+  const newScores = __privateMethod(this, _calculateScores, calculateScores_fn).call(this, newData);
+  const newScoresHaveChanged = !dequal(newScores, __privateGet(this, _scores));
+  if (newScoresHaveChanged) {
+    __privateSet(this, _scores, newScores);
+    __privateGet(this, _mitt3).emit("scoresUpdated", newScores);
+    __privateGet(this, _mitt3).emit("log", ["info", 3, newScores]);
+  }
+};
+_calculateScores = /* @__PURE__ */ new WeakSet();
+calculateScores_fn = function(newData) {
+  var _a;
+  let newScores = { ...newData.scores };
+  for (const session in newData.sessionScores) {
+    newScores[session] = ((_a = newScores[session]) != null ? _a : 0) + newData.sessionScores[session];
+  }
+  newScores = this.manifest.computeAggregateDimensions(newScores);
+  return newScores;
+};
+var isBrowser = typeof top !== "undefined";
+function enableContextDevTools(options) {
+  return {
+    logDrain: (message) => {
+      if (!isBrowser) {
+        return;
+      }
+      top == null ? void 0 : top.postMessage(
+        {
+          type: "uniform:context:log",
+          message
+        },
+        window.location.origin
+      );
+    },
+    init: (context) => {
+      const personalizations = [];
+      const tests = [];
+      const onContextDataUpdated = () => {
+        if (!isBrowser) {
+          return;
+        }
+        top == null ? void 0 : top.postMessage(
+          {
+            type: "uniform:context:data",
+            data: {
+              scores: context.scores,
+              data: context.storage.data,
+              manifest: context.manifest.data,
+              personalizations,
+              tests
+            }
+          },
+          window.location.origin
+        );
+      };
+      const onPersonalizationResult = (e) => {
+        if (!e.changed)
+          return;
+        personalizations.push(e);
+      };
+      const onTestResult = (e) => {
+        if (!e.variantAssigned)
+          return;
+        tests.push(e);
+      };
+      if (isBrowser) {
+        window.__UNIFORM_DEVTOOLS_CONTEXT_INSTANCE__ = context;
+        try {
+          top == null ? void 0 : top.addEventListener("message", async (event) => {
+            if (!event.data) {
+              return;
+            }
+            const message = event.data;
+            await handleMessageFromDevTools({
+              message,
+              context,
+              afterMessageReceived: options == null ? void 0 : options.onAfterMessageReceived
+            });
+          });
+        } catch (e) {
+          console.warn(
+            "Unable to initialize Uniform Context DevTools because it is in a cross-domain iframe.",
+            e
+          );
+        }
+        top == null ? void 0 : top.postMessage(
+          {
+            type: "uniform:context:hello",
+            uiVersion: 2
+          },
+          window.location.origin
+        );
+        onContextDataUpdated();
+      }
+      context.events.on("personalizationResult", onPersonalizationResult);
+      context.events.on("testResult", onTestResult);
+      context.events.on("scoresUpdated", onContextDataUpdated);
+      return () => {
+        context.events.off("scoresUpdated", onContextDataUpdated);
+        context.events.off("personalizationResult", onPersonalizationResult);
+        context.events.off("testResult", onTestResult);
+      };
+    }
+  };
+}
+async function handleMessageFromDevTools({
+  message,
+  context,
+  afterMessageReceived
+}) {
+  let receivedUniformMessage = false;
+  if (message.type === "uniform-in:context:update" && message.newData) {
+    receivedUniformMessage = true;
+    await context.update(message.newData);
+  }
+  if (message.type === "uniform-in:context:commands" && message.commands && Array.isArray(message.commands)) {
+    receivedUniformMessage = true;
+    await context.storage.updateData(message.commands);
+  }
+  if (message.type === "uniform-in:context:forget") {
+    receivedUniformMessage = true;
+    await context.forget(false);
+  }
+  if (receivedUniformMessage && typeof afterMessageReceived === "function") {
+    afterMessageReceived(message);
+  }
+}
+var dc = (0, import_rfdc2.default)();
+var dc2 = (0, import_rfdc3.default)();
+
+// src/components/DefaultUniformClientContext.tsx
+import { useRouter } from "next/navigation";
+
 // src/context/createClientUniformContext.ts
 import { createUniformContext } from "@uniformdev/canvas-next-rsc-shared";
 var createClientUniformContext = (options) => {
@@ -98,10 +909,10 @@ var createClientUniformContext = (options) => {
 };
 
 // src/hooks/useInitUniformContext.ts
-import { useEffect as useEffect4, useState as useState3 } from "react";
+import { useEffect as useEffect6, useState as useState5 } from "react";
 var useInitUniformContext = (callback) => {
-  const [called, setCalled] = useState3(false);
-  useEffect4(() => {
+  const [called, setCalled] = useState5(false);
+  useEffect6(() => {
     if (typeof window === "undefined" || called || typeof window.__UNIFORM_CONTEXT__ !== "undefined") {
       return;
     }
@@ -113,10 +924,27 @@ var useInitUniformContext = (callback) => {
 };
 
 // src/components/DefaultUniformClientContext.tsx
-var DefaultUniformClientContext = ({ manifest }) => {
+var DefaultUniformClientContext = ({
+  manifest,
+  disableDevTools,
+  defaultConsent
+}) => {
+  const router = useRouter();
   useInitUniformContext(() => {
+    const plugins = [];
+    if (!disableDevTools) {
+      plugins.push(
+        enableContextDevTools({
+          onAfterMessageReceived: () => {
+            router.refresh();
+          }
+        })
+      );
+    }
     return createClientUniformContext({
-      manifest
+      manifest,
+      plugins,
+      defaultConsent
     });
   });
   return null;
@@ -125,12 +953,12 @@ var DefaultUniformClientContext = ({ manifest }) => {
 // src/components/PersonalizeClient.ts
 import { CANVAS_PERSONALIZE_SLOT } from "@uniformdev/canvas";
 import { runPersonalization } from "@uniformdev/canvas-next-rsc-shared";
-import { createElement, Fragment as Fragment3, useEffect as useEffect5, useState as useState4 } from "react";
+import { createElement, Fragment as Fragment3, useEffect as useEffect7, useState as useState6 } from "react";
 var PersonalizeClient = (props) => {
   const { slots } = props;
   const { context } = useUniformContext();
-  const [indexesToShow, setIndexesToShow] = useState4(props.indexes);
-  useEffect5(() => {
+  const [indexesToShow, setIndexesToShow] = useState6(props.indexes);
+  useEffect7(() => {
     const result = runPersonalization({
       ...props,
       contextInstance: context
@@ -147,13 +975,13 @@ var PersonalizeClient = (props) => {
 // src/components/TestClient.ts
 import { CANVAS_TEST_SLOT } from "@uniformdev/canvas";
 import { runTest } from "@uniformdev/canvas-next-rsc-shared";
-import { createElement as createElement2, Fragment as Fragment4, useEffect as useEffect6, useState as useState5 } from "react";
+import { createElement as createElement2, Fragment as Fragment4, useEffect as useEffect8, useState as useState7 } from "react";
 var TestClient = (props) => {
   var _a;
   const { slots } = props;
   const { context } = useUniformContext();
-  const [index, setIndex] = useState5(0);
-  useEffect6(() => {
+  const [index, setIndex] = useState7(0);
+  useEffect8(() => {
     const result = runTest({
       ...props,
       contextInstance: context
@@ -172,11 +1000,11 @@ import {
   IN_CONTEXT_EDITOR_QUERY_STRING_PARAM as IN_CONTEXT_EDITOR_QUERY_STRING_PARAM2,
   isAllowedReferrer
 } from "@uniformdev/canvas";
-import { useRouter, useSearchParams as useSearchParams3 } from "next/navigation";
-import { useEffect as useEffect7, useMemo, useRef } from "react";
+import { useRouter as useRouter2, useSearchParams as useSearchParams3 } from "next/navigation";
+import { useEffect as useEffect9, useMemo, useRef } from "react";
 import { Fragment as Fragment5, jsx as jsx3 } from "react/jsx-runtime";
 var UniformScript = () => {
-  const router = useRouter();
+  const router = useRouter2();
   const params = useSearchParams3();
   const needsToRefreshRef = useRef(false);
   const enabled = params.get(IN_CONTEXT_EDITOR_QUERY_STRING_PARAM2) === "true";
@@ -191,7 +1019,7 @@ var UniformScript = () => {
     });
     return instance;
   }, []);
-  useEffect7(() => {
+  useEffect9(() => {
     if (!channel) {
       return;
     }
@@ -208,7 +1036,7 @@ var UniformScript = () => {
       unsubscribeFromEditorUpdates();
     };
   }, [channel, router]);
-  useEffect7(() => {
+  useEffect9(() => {
     if (typeof window === "undefined") {
       return;
     }
@@ -229,7 +1057,7 @@ var UniformScript = () => {
       existing.remove();
     }
   }, [enabled]);
-  useEffect7(() => {
+  useEffect9(() => {
     const handleBlurChange = () => {
       if (needsToRefreshRef.current) {
         router.refresh();
@@ -244,6 +1072,8 @@ var UniformScript = () => {
   return /* @__PURE__ */ jsx3(Fragment5, {});
 };
 export {
+  ClientContextPersonalizationTransfer,
+  ClientContextTestTransfer,
   ClientContextUpdate,
   ClientContextualEditingComponentWrapper,
   ContextUpdateTransferClient,
@@ -255,3 +1085,8 @@ export {
   useInitUniformContext,
   useUniformContext
 };
+/*! Bundled license information:
+
+js-cookie/dist/js.cookie.mjs:
+  (*! js-cookie v3.0.5 | MIT *)
+*/