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

package/dist/index.js

@@ -1,8 +1,8 @@
-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-BKcD4JZK.js";
-import "./symbols-sql1_mdx.js";
-import '@ember/debug';
+export { C as CacheHandler, F as Fetch, z as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, E as setIdentifierForgetMethod, B as setIdentifierGenerationMethod, G as setIdentifierResetMethod, D as setIdentifierUpdateMethod, H as setKeyInfoForResource, s as storeFor, A as useRecommendedStore } from "./index-CQP2NSqg.js";
+import "./symbols-3C1OkYtZ.js";
+import "./configure-DPUFCemT.js";
 import '@embroider/macros';
-import './utils/string.js';
-import "./configure-C3x8YXzL.js";
 import "./default-cache-policy-D7_u4YRH.js";
+import '@ember/debug';
+import './utils/string.js';
 import './types/runtime.js';

package/dist/reactive/-private.js

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

package/dist/reactive.js

@@ -1,129 +1,4 @@
-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-BKcD4JZK.js";
-export { a as Checkout } from "./symbols-sql1_mdx.js";
-import './types/request.js';
-import '@embroider/macros';
-import '@ember/debug';
-import './utils/string.js';
-import "./configure-C3x8YXzL.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 { u as SchemaService, p as checkout, y as commit, v as fromIdentity, q as instantiateRecord, x as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-CQP2NSqg.js";
+export { C as Checkout } from "./symbols-3C1OkYtZ.js";
+export { f as createRequestSubscription, i as getPromiseState, h as getRequestState } from "./configure-DPUFCemT.js";
+import '@embroider/macros';

package/dist/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-oqoLC9rz.js";
+export { c as createDeferred, g as getPromiseResult, s as setPromiseResult } from "./future-BKkJJkj7.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/signals/-leaked.js

@@ -0,0 +1 @@
+export { D as DISPOSE, a as defineGate, d as defineNonEnumerableSignal, b as defineSignal, e as entangleSignal, g as gate, m as memoized, n as notifyInternalSignal, p as peekInternalSignal, s as signal, w as waitFor, c as withSignalStore } from "../configure-DPUFCemT.js";

package/dist/store/-private.js

@@ -1,2 +1 @@
-export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, B as Signals, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, I as consumeInternalSignal, F as createInternalMemo, l as createLegacyManyArray, p as createRequestSubscription, z as defineGate, A as defineNonEnumerableSignal, y as defineSignal, e as ensureStringId, x as entangleInitiallyStaleSignal, w as entangleSignal, f as fastPush, v as gate, J as getOrCreateInternalSignal, q as getRequestState, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, u as memoized, H as notifyInternalSignal, E as peekInternalSignal, r as recordIdentifierFor, j as setRecordIdentifier, t as signal, s as storeFor, G as withSignalStore } from "../index-BKcD4JZK.js";
-export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "../configure-C3x8YXzL.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, l as createLegacyManyArray, e as ensureStringId, f as fastPush, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, r as recordIdentifierFor, j as setRecordIdentifier, s as storeFor } from "../index-CQP2NSqg.js";

package/dist/types/-private.js

@@ -1,6 +1,6 @@
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const name = "@warp-drive/core";
-const version = "5.8.0-alpha.40";
+const version = "5.8.0-alpha.41";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import