@cedarjs/web 4.0.0-canary.13669 → 4.0.0-canary.13670

package/dist/cjs/bundled/apollo-upload-client.js

@@ -109,13 +109,13 @@ function wrapConsoleMethod(name) {
 })(invariant || (invariant = {}));
 
 // ../../node_modules/@apollo/client/version.js
-var version = "3.13.9";
+var version = "3.14.1";
 
 // ../../node_modules/@apollo/client/utilities/globals/maybe.js
 function maybe(thunk) {
   try {
     return thunk();
-  } catch (_a2) {
+  } catch (_a3) {
   }
 }
 
@@ -203,7 +203,7 @@ function stringify(arg) {
   }
   try {
     return stringifyForDisplay(arg, 2).slice(0, 1e3);
-  } catch (_a2) {
+  } catch (_a3) {
     return "<non-serializable>";
   }
 }
@@ -1266,8 +1266,8 @@ function getCurrentCacheSizes() {
     "inMemoryCache.executeSelectionSet": 5e4,
     "inMemoryCache.executeSubSelectedArray": 1e4
   };
-  return Object.fromEntries(Object.entries(defaults).map(function(_a2) {
-    var k = _a2[0], v = _a2[1];
+  return Object.fromEntries(Object.entries(defaults).map(function(_a3) {
+    var k = _a3[0], v = _a3[1];
     return [
       k,
       cacheSizes[k] || v
@@ -1275,12 +1275,12 @@ function getCurrentCacheSizes() {
   }));
 }
 function _getApolloClientMemoryInternals() {
-  var _a2, _b, _c, _d, _e;
+  var _a3, _b, _c, _d, _e;
   if (!(globalThis.__DEV__ !== false))
     throw new Error("only supported in development mode");
   return {
     limits: getCurrentCacheSizes(),
-    sizes: __assign({ print: (_a2 = globalCaches.print) === null || _a2 === void 0 ? void 0 : _a2.call(globalCaches), parser: (_b = globalCaches.parser) === null || _b === void 0 ? void 0 : _b.call(globalCaches), canonicalStringify: (_c = globalCaches.canonicalStringify) === null || _c === void 0 ? void 0 : _c.call(globalCaches), links: linkInfo(this.link), queryManager: {
+    sizes: __assign({ print: (_a3 = globalCaches.print) === null || _a3 === void 0 ? void 0 : _a3.call(globalCaches), parser: (_b = globalCaches.parser) === null || _b === void 0 ? void 0 : _b.call(globalCaches), canonicalStringify: (_c = globalCaches.canonicalStringify) === null || _c === void 0 ? void 0 : _c.call(globalCaches), links: linkInfo(this.link), queryManager: {
       getDocumentInfo: this["queryManager"]["transformCache"].size,
       documentTransforms: transformInfo(this["queryManager"].documentTransform)
     } }, (_e = (_d = this.cache).getMemoryInternals) === null || _e === void 0 ? void 0 : _e.call(_d))
@@ -1325,9 +1325,9 @@ function recurseTransformInfo(transform) {
   ], recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["left"]), true), recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["right"]), true).filter(isDefined) : [];
 }
 function linkInfo(link) {
-  var _a2;
+  var _a3;
   return link ? __spreadArray(__spreadArray([
-    (_a2 = link === null || link === void 0 ? void 0 : link.getMemoryInternals) === null || _a2 === void 0 ? void 0 : _a2.call(link)
+    (_a3 = link === null || link === void 0 ? void 0 : link.getMemoryInternals) === null || _a3 === void 0 ? void 0 : _a3.call(link)
   ], linkInfo(link === null || link === void 0 ? void 0 : link.left), true), linkInfo(link === null || link === void 0 ? void 0 : link.right), true).filter(isDefined) : [];
 }
 
@@ -1340,6 +1340,379 @@ function getOperationName(doc) {
   })[0] || null;
 }
 
+// ../../node_modules/optimism/node_modules/@wry/trie/lib/index.js
+var { forEach, slice } = Array.prototype;
+var { hasOwnProperty } = Object.prototype;
+
+// ../../node_modules/@wry/context/lib/slot.js
+var currentContext = null;
+var MISSING_VALUE = {};
+var idCounter = 1;
+var makeSlotClass = () => class Slot {
+  constructor() {
+    this.id = [
+      "slot",
+      idCounter++,
+      Date.now(),
+      Math.random().toString(36).slice(2)
+    ].join(":");
+  }
+  hasValue() {
+    for (let context = currentContext; context; context = context.parent) {
+      if (this.id in context.slots) {
+        const value = context.slots[this.id];
+        if (value === MISSING_VALUE)
+          break;
+        if (context !== currentContext) {
+          currentContext.slots[this.id] = value;
+        }
+        return true;
+      }
+    }
+    if (currentContext) {
+      currentContext.slots[this.id] = MISSING_VALUE;
+    }
+    return false;
+  }
+  getValue() {
+    if (this.hasValue()) {
+      return currentContext.slots[this.id];
+    }
+  }
+  withValue(value, callback, args, thisArg) {
+    const slots = {
+      __proto__: null,
+      [this.id]: value
+    };
+    const parent = currentContext;
+    currentContext = { parent, slots };
+    try {
+      return callback.apply(thisArg, args);
+    } finally {
+      currentContext = parent;
+    }
+  }
+  // Capture the current context and wrap a callback function so that it
+  // reestablishes the captured context when called.
+  static bind(callback) {
+    const context = currentContext;
+    return function() {
+      const saved = currentContext;
+      try {
+        currentContext = context;
+        return callback.apply(this, arguments);
+      } finally {
+        currentContext = saved;
+      }
+    };
+  }
+  // Immediately run a callback function without any captured context.
+  static noContext(callback, args, thisArg) {
+    if (currentContext) {
+      const saved = currentContext;
+      try {
+        currentContext = null;
+        return callback.apply(thisArg, args);
+      } finally {
+        currentContext = saved;
+      }
+    } else {
+      return callback.apply(thisArg, args);
+    }
+  }
+};
+function maybe2(fn) {
+  try {
+    return fn();
+  } catch (ignored) {
+  }
+}
+var globalKey = "@wry/context:Slot";
+var host = (
+  // Prefer globalThis when available.
+  // https://github.com/benjamn/wryware/issues/347
+  maybe2(() => globalThis) || // Fall back to global, which works in Node.js and may be converted by some
+  // bundlers to the appropriate identifier (window, self, ...) depending on the
+  // bundling target. https://github.com/endojs/endo/issues/576#issuecomment-1178515224
+  maybe2(() => global) || // Otherwise, use a dummy host that's local to this module. We used to fall
+  // back to using the Array constructor as a namespace, but that was flagged in
+  // https://github.com/benjamn/wryware/issues/347, and can be avoided.
+  /* @__PURE__ */ Object.create(null)
+);
+var globalHost = host;
+var Slot = globalHost[globalKey] || // Earlier versions of this package stored the globalKey property on the Array
+// constructor, so we check there as well, to prevent Slot class duplication.
+Array[globalKey] || (function(Slot2) {
+  try {
+    Object.defineProperty(globalHost, globalKey, {
+      value: Slot2,
+      enumerable: false,
+      writable: false,
+      // When it was possible for globalHost to be the Array constructor (a
+      // legacy Slot dedup strategy), it was important for the property to be
+      // configurable:true so it could be deleted. That does not seem to be as
+      // important when globalHost is the global object, but I don't want to
+      // cause similar problems again, and configurable:true seems safest.
+      // https://github.com/endojs/endo/issues/576#issuecomment-1178274008
+      configurable: true
+    });
+  } finally {
+    return Slot2;
+  }
+})(makeSlotClass());
+
+// ../../node_modules/@wry/context/lib/index.js
+var { bind, noContext } = Slot;
+
+// ../../node_modules/optimism/lib/context.js
+var parentEntrySlot = new Slot();
+
+// ../../node_modules/optimism/lib/helpers.js
+var { hasOwnProperty: hasOwnProperty2 } = Object.prototype;
+var arrayFromSet = Array.from || function(set) {
+  const array = [];
+  set.forEach((item) => array.push(item));
+  return array;
+};
+function maybeUnsubscribe(entryOrDep) {
+  const { unsubscribe } = entryOrDep;
+  if (typeof unsubscribe === "function") {
+    entryOrDep.unsubscribe = void 0;
+    unsubscribe();
+  }
+}
+
+// ../../node_modules/optimism/lib/entry.js
+var emptySetPool = [];
+var POOL_TARGET_SIZE = 100;
+function assert(condition, optionalMessage) {
+  if (!condition) {
+    throw new Error(optionalMessage || "assertion failure");
+  }
+}
+function valueIs(a, b) {
+  const len = a.length;
+  return (
+    // Unknown values are not equal to each other.
+    len > 0 && // Both values must be ordinary (or both exceptional) to be equal.
+    len === b.length && // The underlying value or exception must be the same.
+    a[len - 1] === b[len - 1]
+  );
+}
+function valueGet(value) {
+  switch (value.length) {
+    case 0:
+      throw new Error("unknown value");
+    case 1:
+      return value[0];
+    case 2:
+      throw value[1];
+  }
+}
+function valueCopy(value) {
+  return value.slice(0);
+}
+var Entry = class _Entry {
+  constructor(fn) {
+    this.fn = fn;
+    this.parents = /* @__PURE__ */ new Set();
+    this.childValues = /* @__PURE__ */ new Map();
+    this.dirtyChildren = null;
+    this.dirty = true;
+    this.recomputing = false;
+    this.value = [];
+    this.deps = null;
+    ++_Entry.count;
+  }
+  peek() {
+    if (this.value.length === 1 && !mightBeDirty(this)) {
+      rememberParent(this);
+      return this.value[0];
+    }
+  }
+  // This is the most important method of the Entry API, because it
+  // determines whether the cached this.value can be returned immediately,
+  // or must be recomputed. The overall performance of the caching system
+  // depends on the truth of the following observations: (1) this.dirty is
+  // usually false, (2) this.dirtyChildren is usually null/empty, and thus
+  // (3) valueGet(this.value) is usually returned without recomputation.
+  recompute(args) {
+    assert(!this.recomputing, "already recomputing");
+    rememberParent(this);
+    return mightBeDirty(this) ? reallyRecompute(this, args) : valueGet(this.value);
+  }
+  setDirty() {
+    if (this.dirty)
+      return;
+    this.dirty = true;
+    reportDirty(this);
+    maybeUnsubscribe(this);
+  }
+  dispose() {
+    this.setDirty();
+    forgetChildren(this);
+    eachParent(this, (parent, child) => {
+      parent.setDirty();
+      forgetChild(parent, this);
+    });
+  }
+  forget() {
+    this.dispose();
+  }
+  dependOn(dep2) {
+    dep2.add(this);
+    if (!this.deps) {
+      this.deps = emptySetPool.pop() || /* @__PURE__ */ new Set();
+    }
+    this.deps.add(dep2);
+  }
+  forgetDeps() {
+    if (this.deps) {
+      arrayFromSet(this.deps).forEach((dep2) => dep2.delete(this));
+      this.deps.clear();
+      emptySetPool.push(this.deps);
+      this.deps = null;
+    }
+  }
+};
+Entry.count = 0;
+function rememberParent(child) {
+  const parent = parentEntrySlot.getValue();
+  if (parent) {
+    child.parents.add(parent);
+    if (!parent.childValues.has(child)) {
+      parent.childValues.set(child, []);
+    }
+    if (mightBeDirty(child)) {
+      reportDirtyChild(parent, child);
+    } else {
+      reportCleanChild(parent, child);
+    }
+    return parent;
+  }
+}
+function reallyRecompute(entry, args) {
+  forgetChildren(entry);
+  parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);
+  if (maybeSubscribe(entry, args)) {
+    setClean(entry);
+  }
+  return valueGet(entry.value);
+}
+function recomputeNewValue(entry, args) {
+  entry.recomputing = true;
+  const { normalizeResult } = entry;
+  let oldValueCopy;
+  if (normalizeResult && entry.value.length === 1) {
+    oldValueCopy = valueCopy(entry.value);
+  }
+  entry.value.length = 0;
+  try {
+    entry.value[0] = entry.fn.apply(null, args);
+    if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) {
+      try {
+        entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]);
+      } catch (_a3) {
+      }
+    }
+  } catch (e) {
+    entry.value[1] = e;
+  }
+  entry.recomputing = false;
+}
+function mightBeDirty(entry) {
+  return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);
+}
+function setClean(entry) {
+  entry.dirty = false;
+  if (mightBeDirty(entry)) {
+    return;
+  }
+  reportClean(entry);
+}
+function reportDirty(child) {
+  eachParent(child, reportDirtyChild);
+}
+function reportClean(child) {
+  eachParent(child, reportCleanChild);
+}
+function eachParent(child, callback) {
+  const parentCount = child.parents.size;
+  if (parentCount) {
+    const parents = arrayFromSet(child.parents);
+    for (let i = 0; i < parentCount; ++i) {
+      callback(parents[i], child);
+    }
+  }
+}
+function reportDirtyChild(parent, child) {
+  assert(parent.childValues.has(child));
+  assert(mightBeDirty(child));
+  const parentWasClean = !mightBeDirty(parent);
+  if (!parent.dirtyChildren) {
+    parent.dirtyChildren = emptySetPool.pop() || /* @__PURE__ */ new Set();
+  } else if (parent.dirtyChildren.has(child)) {
+    return;
+  }
+  parent.dirtyChildren.add(child);
+  if (parentWasClean) {
+    reportDirty(parent);
+  }
+}
+function reportCleanChild(parent, child) {
+  assert(parent.childValues.has(child));
+  assert(!mightBeDirty(child));
+  const childValue = parent.childValues.get(child);
+  if (childValue.length === 0) {
+    parent.childValues.set(child, valueCopy(child.value));
+  } else if (!valueIs(childValue, child.value)) {
+    parent.setDirty();
+  }
+  removeDirtyChild(parent, child);
+  if (mightBeDirty(parent)) {
+    return;
+  }
+  reportClean(parent);
+}
+function removeDirtyChild(parent, child) {
+  const dc = parent.dirtyChildren;
+  if (dc) {
+    dc.delete(child);
+    if (dc.size === 0) {
+      if (emptySetPool.length < POOL_TARGET_SIZE) {
+        emptySetPool.push(dc);
+      }
+      parent.dirtyChildren = null;
+    }
+  }
+}
+function forgetChildren(parent) {
+  if (parent.childValues.size > 0) {
+    parent.childValues.forEach((_value, child) => {
+      forgetChild(parent, child);
+    });
+  }
+  parent.forgetDeps();
+  assert(parent.dirtyChildren === null);
+}
+function forgetChild(parent, child) {
+  child.parents.delete(parent);
+  parent.childValues.delete(child);
+  removeDirtyChild(parent, child);
+}
+function maybeSubscribe(entry, args) {
+  if (typeof entry.subscribe === "function") {
+    try {
+      maybeUnsubscribe(entry);
+      entry.unsubscribe = entry.subscribe.apply(null, args);
+    } catch (e) {
+      entry.setDirty();
+      return false;
+    }
+  }
+  return true;
+}
+
 // ../../node_modules/@apollo/client/utilities/graphql/print.js
 var printCache;
 var print2 = Object.assign(function(ast) {
@@ -1612,7 +1985,7 @@ var Observable = /* @__PURE__ */ (function() {
     }
     return new Subscription(observer, this._subscriber);
   };
-  _proto3.forEach = function forEach(fn) {
+  _proto3.forEach = function forEach2(fn) {
     var _this = this;
     return new Promise(function(resolve, reject) {
       if (typeof fn !== "function") {
@@ -1928,6 +2301,21 @@ if (!prototype[fakeObsSymbol]) {
   };
 }
 
+// ../../node_modules/@apollo/client/utilities/deprecation/index.js
+var _a2;
+var muteAllDeprecations = /* @__PURE__ */ Symbol.for("apollo.deprecations");
+var deprecationsSlot = /* @__PURE__ */ Symbol.for("apollo.deprecations.slot");
+var global2 = global_default;
+var slot = (_a2 = global2[deprecationsSlot]) !== null && _a2 !== void 0 ? _a2 : global2[deprecationsSlot] = new Slot();
+function isMuted(name) {
+  return global2[muteAllDeprecations] || (slot.getValue() || []).includes(name);
+}
+function warnDeprecated(name, cb) {
+  if (!isMuted(name)) {
+    cb();
+  }
+}
+
 // ../../node_modules/@apollo/client/link/utils/throwServerError.js
 var throwServerError = function(response, result2, message) {
   var error = new Error(message);
@@ -1947,10 +2335,10 @@ function validateOperation(operation) {
     "extensions",
     "context"
   ];
-  for (var _i = 0, _a2 = Object.keys(operation); _i < _a2.length; _i++) {
-    var key = _a2[_i];
+  for (var _i = 0, _a3 = Object.keys(operation); _i < _a3.length; _i++) {
+    var key = _a3[_i];
     if (OPERATION_FIELDS.indexOf(key) < 0) {
-      throw newInvariantError(46, key);
+      throw newInvariantError(58, key);
     }
   }
   return operation;
@@ -2044,7 +2432,7 @@ var ApolloLink = (
     ApolloLink2.concat = function(first, second) {
       var firstLink = toLink(first);
       if (isTerminating(firstLink)) {
-        globalThis.__DEV__ !== false && invariant2.warn(38, firstLink);
+        globalThis.__DEV__ !== false && invariant2.warn(47, firstLink);
         return firstLink;
       }
       var nextLink = toLink(second);
@@ -2071,9 +2459,14 @@ var ApolloLink = (
       return ApolloLink2.concat(this, next);
     };
     ApolloLink2.prototype.request = function(operation, forward) {
-      throw newInvariantError(39);
+      throw newInvariantError(48);
     };
     ApolloLink2.prototype.onError = function(error, observer) {
+      if (globalThis.__DEV__ !== false) {
+        warnDeprecated("onError", function() {
+          globalThis.__DEV__ !== false && invariant2.warn(49);
+        });
+      }
       if (observer && observer.error) {
         observer.error(error);
         return false;
@@ -2081,6 +2474,9 @@ var ApolloLink = (
       throw error;
     };
     ApolloLink2.prototype.setOnError = function(fn) {
+      if (globalThis.__DEV__ !== false) {
+        globalThis.__DEV__ !== false && invariant2.warn(50);
+      }
       this.onError = fn;
       return this;
     };
@@ -2098,7 +2494,7 @@ var createSignalIfSupported = function() {
 };
 
 // ../../node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwnProperty3 = Object.prototype.hasOwnProperty;
 function parseJsonBody(response, bodyText) {
   if (response.status >= 300) {
     var getResult = function() {
@@ -2126,7 +2522,7 @@ function parseAndCheckHttpResponse(operations) {
     return response.text().then(function(bodyText) {
       return parseJsonBody(response, bodyText);
     }).then(function(result2) {
-      if (!Array.isArray(result2) && !hasOwnProperty.call(result2, "data") && !hasOwnProperty.call(result2, "errors")) {
+      if (!Array.isArray(result2) && !hasOwnProperty3.call(result2, "data") && !hasOwnProperty3.call(result2, "errors")) {
         throwServerError(response, result2, "Server response was missing for query '".concat(Array.isArray(operations) ? operations.map(function(op) {
           return op.operationName;
         }) : operations.operationName, "'."));
@@ -2142,7 +2538,7 @@ var serializeFetchParameter = function(p, label) {
   try {
     serialized = JSON.stringify(p);
   } catch (e) {
-    var parseError = newInvariantError(42, label, e.message);
+    var parseError = newInvariantError(54, label, e.message);
     parseError.parseError = e;
     throw parseError;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/web",
-  "version": "4.0.0-canary.13669+ae8c467c4",
+  "version": "4.0.0-canary.13670+3bc22c4c4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
@@ -143,9 +143,9 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@apollo/client": "3.13.9",
-    "@cedarjs/auth": "4.0.0-canary.13669",
-    "@cedarjs/server-store": "4.0.0-canary.13669",
+    "@apollo/client": "3.14.1",
+    "@cedarjs/auth": "4.0.0-canary.13670",
+    "@cedarjs/server-store": "4.0.0-canary.13670",
     "@dr.pogodin/react-helmet": "2.0.4",
     "@whatwg-node/fetch": "0.10.13",
     "apollo-upload-client": "18.0.1",
@@ -164,8 +164,8 @@
     "@babel/core": "^7.26.10",
     "@babel/plugin-transform-runtime": "7.29.0",
     "@babel/runtime": "7.29.2",
-    "@cedarjs/framework-tools": "4.0.0-canary.13669",
-    "@cedarjs/internal": "4.0.0-canary.13669",
+    "@cedarjs/framework-tools": "4.0.0-canary.13670",
+    "@cedarjs/internal": "4.0.0-canary.13670",
     "@rollup/plugin-babel": "6.1.0",
     "@testing-library/jest-dom": "6.9.1",
     "@testing-library/react": "14.3.1",
@@ -189,5 +189,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ae8c467c424198bf05acb2e818118a04695c47cb"
+  "gitHead": "3bc22c4c4e25c716438a18a2585d50e25c8e1c0d"
 }