@warp-drive/core 5.8.0-alpha.4 → 5.8.0-alpha.40

package/dist/unpkg/dev-deprecated/index.js

@@ -0,0 +1,5 @@
+export { C as CacheHandler, V as Fetch, W as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, $ as setIdentifierForgetMethod, Y as setIdentifierGenerationMethod, a0 as setIdentifierResetMethod, Z as setIdentifierUpdateMethod, a1 as setKeyInfoForResource, s as storeFor, X as useRecommendedStore } from "./index-BBlq5is_.js";
+import "./-private-3C1OkYtZ.js";
+import "./configure-BC66sfNO.js";
+import './store.js';
+import './types/runtime.js';

package/dist/unpkg/dev-deprecated/reactive/-private.js

@@ -0,0 +1 @@
+export { a as Context } from "../-private-3C1OkYtZ.js";

package/dist/unpkg/dev-deprecated/reactive.js

@@ -0,0 +1,127 @@
+export { N as SchemaService, K as checkout, T as commit, p as createRequestSubscription, P as fromIdentity, U as getPromiseState, q as getRequestState, L as instantiateRecord, Q as registerDerivations, M as teardownRecord, O as withDefaults } from "./index-BBlq5is_.js";
+export { C as Checkout } from "./-private-3C1OkYtZ.js";
+import './types/request.js';
+import "./runtime-DfhJzpZH.js";
+import "./configure-BC66sfNO.js";
+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 { getExpensiveRequestSubscription };