@warp-drive/core 5.7.0-alpha.13 → 5.7.0-alpha.15

package/dist/index.js

@@ -1,11 +1,12 @@
 import { setLogging, getRuntimeConfig } from './types/runtime.js';
-import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-COmAnXUQ.js";
+import { a as cloneResponseProperties, I as IS_CACHE_HANDLER, b as assertValidRequest, e as executeNextHandler, d as getRequestResult, u as upgradePromise, s as setPromiseResult, f as clearRequestResult } from "./context-kQXhkeBj.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { w as waitFor } from "./configure-B48bFHOl.js";
 import { peekUniversalTransient, setUniversalTransient } from './types/-private.js';
-export { C as CacheHandler, S as Store, r as recordIdentifierFor, O as setIdentifierForgetMethod, L as setIdentifierGenerationMethod, P as setIdentifierResetMethod, N as setIdentifierUpdateMethod, Q as setKeyInfoForResource, s as storeFor } from "./request-state-BWYju5O9.js";
+export { C as CacheHandler, S as Store, r as recordIdentifierFor, M as setIdentifierForgetMethod, K as setIdentifierGenerationMethod, N as setIdentifierResetMethod, L as setIdentifierUpdateMethod, O as setKeyInfoForResource, s as storeFor } from "./request-state-CQ0Q6d1V.js";
 import '@ember/debug';
 import './utils/string.js';
+import "./symbols-sql1_mdx.js";
 
 // Lazily close over fetch to avoid breaking Mirage
 const _fetch = typeof fetch !== 'undefined' ? (...args) => fetch(...args) : typeof FastBoot !== 'undefined' ? (...args) => FastBoot.require('node-fetch')(...args) : () => {
@@ -60,6 +61,9 @@ const Fetch = {
       } else {
         e.statusText = 'Unknown Network Error';
         e.status = 0;
+        if (!(e instanceof DOMException)) {
+          e.code = 0;
+        }
         e.isRequestError = true;
       }
       throw e;

package/dist/reactive/-private.js

@@ -1 +1 @@
-export { C as Context } from "../symbols-BoONANuz.js";
+export { C as Context } from "../symbols-sql1_mdx.js";

package/dist/reactive.js

@@ -1,7 +1,8 @@
+import { F as ReactiveResource, G as isNonIdentityCacheableField, H as getFieldCacheKeyStrict, r as recordIdentifierFor, z as withSignalStore } from "./request-state-CQ0Q6d1V.js";
+export { I as checkout, J as commit } from "./request-state-CQ0Q6d1V.js";
 import { isResourceSchema } from './types/schema/fields.js';
-import { H as ReactiveResource, J as isNonIdentityCacheableField, K as getFieldCacheKeyStrict, r as recordIdentifierFor, B as withSignalStore } from "./request-state-BWYju5O9.js";
-import { D as Destroy, C as Context } from "./symbols-BoONANuz.js";
-export { a as Checkout } from "./symbols-BoONANuz.js";
+import { D as Destroy, C as Context } from "./symbols-sql1_mdx.js";
+export { a as Checkout } from "./symbols-sql1_mdx.js";
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { warn, deprecate } from '@ember/debug';
 import './index.js';
@@ -772,4 +773,125 @@ function mergeMap(base, toApply) {
     base.set(key, value);
   }
 }
-export { SchemaService, fromIdentity, instantiateRecord, registerDerivations, teardownRecord, withDefaults };
+const Subscriptions = new WeakMap();
+
+/**
+ * `ExpensiveSubscription` is a mechanism for non-reactive
+ * frameworks such as `react` to integrate with WarpDrive.
+ *
+ * This mechanism should never be used by frameworks or libraries
+ * that support fine-grained reactivity.
+ *
+ * ExpensiveSubscription is expensive *because* it doubles the number
+ * of notification callbacks required for each resource contained in
+ * the request being subscribed to. The more requests in-use, the more
+ * this cost adds up.
+ */
+class ExpensiveSubscription {
+  constructor(store, request) {
+    this._store = store;
+    this._request = request;
+    this._callbacks = new Set();
+    this._resources = new Map();
+    this._subscription = store.notifications.subscribe(request, this._notifyRequestChange);
+    this._updateResourceCallbacks();
+  }
+  _updateResourceCallbacks() {
+    const request = this._request;
+    const store = this._store;
+    const {
+      notifications
+    } = store;
+    const req = store.cache.peek(request);
+    const resources = this._resources;
+    const isInitialSubscription = resources.size === 0;
+    if (req && 'data' in req) {
+      if (Array.isArray(req.data)) {
+        for (const resourceKey of req.data) {
+          if (isInitialSubscription || !resources.has(resourceKey)) {
+            resources.set(resourceKey, notifications.subscribe(resourceKey, this._scheduleNotify));
+          }
+        }
+      } else if (req.data) {
+        if (isInitialSubscription || !resources.has(req.data)) {
+          resources.set(req.data, notifications.subscribe(req.data, this._scheduleNotify));
+        }
+      }
+    }
+    if (req && 'included' in req && Array.isArray(req.included)) {
+      for (const resourceKey of req.included) {
+        if (isInitialSubscription || !resources.has(resourceKey)) {
+          resources.set(resourceKey, notifications.subscribe(resourceKey, this._scheduleNotify));
+        }
+      }
+    }
+  }
+  _notifyRequestChange = () => {
+    this._updateResourceCallbacks();
+    this._scheduleNotify();
+  };
+  _scheduleNotify = () => {
+    this._notify = this._notify || Promise.resolve().then(() => {
+      for (const callback of this._callbacks) {
+        callback();
+      }
+      this._notify = null;
+    });
+  };
+  addWatcher(callback) {
+    this._callbacks.add(callback);
+  }
+  removeWatcher(callback) {
+    this._callbacks.delete(callback);
+    if (this._callbacks.size === 0) {
+      this.destroy();
+    }
+  }
+  destroy() {
+    Subscriptions.delete(this._request);
+    const {
+      notifications
+    } = this._store;
+    if (this._subscription) {
+      notifications.unsubscribe(this._subscription);
+    }
+    for (const token of this._resources.values()) {
+      notifications.unsubscribe(token);
+    }
+    this._callbacks.clear();
+    this._resources.clear();
+  }
+}
+
+/**
+ * Creates an {@link ExpensiveSubscription} for the {@link RequestKey}
+ * if one does not already exist and adds a watcher to it.
+ *
+ * Returns a cleanup function. This should be called on-mount by a component
+ * that wants to subscribe to a request and cleanup should be called on dismount.
+ *
+ * ::: warning ⚠️ Avoid Using If Your App Supports Fine-grained Reactivity
+ * This mechanism should never be used by frameworks or libraries
+ * that support fine-grained reactivity.
+ * :::
+ *
+ * `ExpensiveSubscription` is a mechanism for non-reactive
+ * frameworks such as `react` to integrate with WarpDrive, for instance
+ * by treating a request as an [external store](https://react.dev/reference/react/useSyncExternalStore)
+ *
+ * `ExpensiveSubscription` is expensive *because* it doubles the number
+ * of notification callbacks required for each resource contained in
+ * the request being subscribed to. The more requests in-use, the more
+ * this cost adds up.
+ */
+function getExpensiveRequestSubscription(store, requestKey, callback) {
+  let subscription = Subscriptions.get(requestKey);
+  if (!subscription) {
+    subscription = new ExpensiveSubscription(store, requestKey);
+  }
+  subscription.addWatcher(callback);
+  return () => {
+    subscription.removeWatcher(callback);
+  };
+}
+export { SchemaService, fromIdentity, getExpensiveRequestSubscription, instantiateRecord, registerDerivations, teardownRecord, withDefaults };