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

package/dist/unpkg/dev/index.js

@@ -1,6 +1,6 @@
-export { C as CacheHandler, U as Fetch, V as RequestManager, j as Store, k as cacheKeyFor, k as recordIdentifierFor, Z as setIdentifierForgetMethod, X as setIdentifierGenerationMethod, $ as setIdentifierResetMethod, Y as setIdentifierUpdateMethod, a0 as setKeyInfoForResource, s as storeFor, W as useRecommendedStore } from "./index-DqhXrNZ_.js";
-import "./-private-3C1OkYtZ.js";
-import './types/request.js';
-import "./configure-BC66sfNO.js";
+export { C as CacheHandler, F as Fetch, y as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, D as setIdentifierForgetMethod, A as setIdentifierGenerationMethod, E as setIdentifierResetMethod, B as setIdentifierUpdateMethod, G as setKeyInfoForResource, s as storeFor, z as useRecommendedStore } from "./index-CepUPZlc.js";
+import "./-private-sql1_mdx.js";
+import "./-leaked-Co0EI6Go.js";
 import './store.js';
+import './types/request.js';
 import './types/runtime.js';

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

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

package/dist/unpkg/dev/reactive.js

@@ -1,127 +1,3 @@
-export { S as SchemaService, c as checkout, a as commit, b as createRequestSubscription, f as fromIdentity, d as getPromiseState, g as getRequestState, i as instantiateRecord, r as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-DqhXrNZ_.js";
-export { C as Checkout } from "./-private-3C1OkYtZ.js";
-import './types/request.js';
-import "./runtime-DGG4CvlW.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 };
+export { q as SchemaService, o as checkout, x as commit, u as fromIdentity, p as instantiateRecord, v as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-CepUPZlc.js";
+export { a as Checkout } from "./-private-sql1_mdx.js";
+export { k as createRequestSubscription, m as getPromiseState, l as getRequestState } from "./-leaked-Co0EI6Go.js";

package/dist/unpkg/dev/request.js

@@ -1 +1,49 @@
-export { i as createDeferred, g as getPromiseResult, s as setPromiseResult, w as withBrand, h as withReactiveResponse, f as withResponseType } from "./request-CA9K0gXq.js";
+export { c as createDeferred, g as getPromiseResult, s as setPromiseResult } from "./future-DFfOzSoe.js";
+
+/**
+ * Brands the supplied object with the supplied response type.
+ *
+ * ```ts
+ * import type { ReactiveDataDocument } from '@warp-drive/core/reactive';
+ * import { withResponseType } from '@warp-drive/core/request';
+ * import type { User } from '#/data/user.ts'
+ *
+ * const result = await store.request(
+ *  withResponseType<ReactiveDataDocument<User>>({ url: '/users/1' })
+ * );
+ *
+ * result.content.data; // will have type User
+ * ```
+ *
+ */
+function withResponseType(obj) {
+  return obj;
+}
+
+/**
+ * Brands the supplied object with the supplied response type
+ * wrapped in {@link ReactiveDataDocument}. This is a convenience for
+ * the common case of using {@link withResponseType} with `ReactiveDataDocument`.
+ *
+ * ```ts
+ * import { withReactiveResponse } from '@warp-drive/core/request';
+ * import type { User } from '#/data/user.ts'
+ *
+ * const result = await store.request(
+ *   withReactiveResponse<User>({ url: '/users/1' })
+ * );
+ *
+ * result.content.data; // will have type User
+ * ```
+ *
+ * @public
+ */
+function withReactiveResponse(obj) {
+  return obj;
+}
+
+/**
+ * @deprecated use {@link withResponseType} instead
+ */
+const withBrand = withResponseType;
+export { withBrand, withReactiveResponse, withResponseType };

package/dist/unpkg/dev/signals/-leaked.js

@@ -0,0 +1 @@
+export { D as DISPOSE, d as defineGate, q as defineNonEnumerableSignal, f as defineSignal, h as entangleSignal, t as gate, u as memoized, n as notifyInternalSignal, p as peekInternalSignal, r as signal, o as waitFor, w as withSignalStore } from "../-leaked-Co0EI6Go.js";

package/dist/unpkg/dev/store/-private.js

@@ -1,7 +1,6 @@
 import '../types/request.js';
-import { e as isResourceKey, h as coerceId } from "../index-DqhXrNZ_.js";
-export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, L as Signals, j as Store, v as StoreMap, _ as _clearCaches, x as _deprecatingNormalize, q as assertPrivateCapabilities, o as assertPrivateStore, Q as consumeInternalSignal, N as createInternalMemo, y as createLegacyManyArray, b as createRequestSubscription, J as defineGate, K as defineNonEnumerableSignal, I as defineSignal, m as ensureStringId, H as entangleInitiallyStaleSignal, G as entangleSignal, n as fastPush, F as gate, T as getOrCreateInternalSignal, g as getRequestState, p as isPrivateStore, l as isRequestKey, z as log, A as logGroup, E as memoized, P as notifyInternalSignal, M as peekInternalSignal, k as recordIdentifierFor, u as setRecordIdentifier, B as signal, s as storeFor, O as withSignalStore } from "../index-DqhXrNZ_.js";
-export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "../configure-BC66sfNO.js";
+import { i as isResourceKey, c as coerceId } from "../index-CepUPZlc.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, g as assertPrivateCapabilities, b as assertPrivateStore, k as createLegacyManyArray, e as ensureStringId, f as fastPush, d as isPrivateStore, a as isRequestKey, l as log, m as logGroup, r as recordIdentifierFor, h as setRecordIdentifier, s as storeFor } from "../index-CepUPZlc.js";
 function isNonEmptyString(str) {
   return Boolean(str && typeof str === 'string');
 }

package/dist/unpkg/dev/types/-private.js

@@ -1,5 +1,5 @@
 const name = "@warp-drive/core";
-const version = "5.8.0-alpha.40";
+const version = "5.8.0-alpha.42";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import