@warp-drive/core 5.6.0-alpha.14 → 5.6.0-alpha.15

package/dist/{request-state-DgwTEXLU.js → request-state-CCOJIj5i.js}

@@ -1,11 +1,11 @@
+import { withBrand, EnableHydration, SkipCache } from './types/request.js';
 import { deprecate, warn } from '@ember/debug';
 import { macroCondition, getGlobalConfig, dependencySatisfies, importSync } from '@embroider/macros';
-import { withBrand, EnableHydration, SkipCache } from './types/request.js';
 import { setLogging, getRuntimeConfig } from './types/runtime.js';
 import { getOrSetGlobal, peekTransient, setTransient } from './types/-private.js';
-import { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, d as willSyncFlushWatchers, A as ARRAY_SIGNAL } from "./configure-BgaZESRo.js";
 import { CACHE_OWNER, DEBUG_STALE_CACHE_OWNER, DEBUG_IDENTIFIER_BUCKET, DEBUG_CLIENT_ORIGINATED } from './types/identifier.js';
 import { dasherize } from './utils/string.js';
+import { a as createSignal, b as consumeSignal, n as notifySignal, c as createMemo, d as willSyncFlushWatchers, A as ARRAY_SIGNAL } from "./configure-B48bFHOl.js";
 import { g as getPromiseResult, s as setPromiseResult } from "./context-COmAnXUQ.js";
 function coerceId(id) {
   if (macroCondition(getGlobalConfig().WarpDrive.deprecations.DEPRECATE_NON_STRICT_ID)) {
@@ -3178,6 +3178,142 @@ class NotificationManager {
     this._cache.clear();
   }
 }
+function isExtensionProp(extensions, prop) {
+  return Boolean(extensions && typeof prop !== 'number' && extensions.has(prop));
+}
+function performObjectExtensionGet(receiver, extensions, signals, prop) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+      {
+        return desc.fn;
+      }
+    case 'readonly-value':
+      {
+        return desc.value;
+      }
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        // we don't consume this signal, since its not a true local.
+        return signal.value;
+      }
+    case 'readonly-field':
+    case 'mutable-field':
+      {
+        return desc.get.call(receiver);
+      }
+    case 'writeonly-field':
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
+          }
+        })() : {};
+        return undefined;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return undefined;
+      }
+  }
+}
+function performExtensionSet(receiver, extensions, signals, prop, value) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+    case 'readonly-value':
+    case 'readonly-field':
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        {
+          throw new Error(`Cannot set extension field ${String(prop)} as it is a ${desc.kind}`);
+        }
+      })() : {};
+      return false;
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        if (signal.value !== value) {
+          // we don't notify this signal, since its not a true local.
+          signal.value = value;
+        }
+        return true;
+      }
+    case 'writeonly-field':
+    case 'mutable-field':
+      {
+        desc.set.call(receiver, value);
+        return true;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return false;
+      }
+  }
+}
+function performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, transaction) {
+  const desc = extensions.get(prop);
+  switch (desc.kind) {
+    case 'method':
+      {
+        let fn = boundFns.get(prop);
+        if (fn === undefined) {
+          fn = function () {
+            consumeInternalSignal(_SIGNAL);
+            transaction(true);
+            const result = Reflect.apply(desc.fn, receiver, arguments);
+            transaction(false);
+            return result;
+          };
+          boundFns.set(prop, fn);
+        }
+        return fn;
+      }
+    case 'mutable-field':
+    case 'readonly-field':
+      {
+        return desc.get.call(receiver);
+      }
+    case 'readonly-value':
+      {
+        return desc.value;
+      }
+    case 'mutable-value':
+      {
+        const signal = getOrCreateInternalSignal(signals, receiver, prop, desc.value);
+        // we don't consume this signal, since its not a true local.
+        return signal.value;
+      }
+    case 'writeonly-field':
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Cannot get extended field ${String(prop)} as its definition has only a setter`);
+          }
+        })() : {};
+        return undefined;
+      }
+    default:
+      {
+        macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+          {
+            throw new Error(`Unhandled extension kind ${desc.kind}`);
+          }
+        })() : {};
+        return undefined;
+      }
+  }
+}
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /*
@@ -3246,6 +3382,12 @@ function safeForEach(instance, arr, store, callback, target) {
   @public
 */
 
+// these are "internally" mutable, they should not be mutated by consumers
+// though this is not currently enforced.
+//
+// all of these should become gated by field-type as they shouldn't be available
+// on request results or non-legacy relationships.
+const MUTABLE_PROPS = ['_updatingPromise', 'isDestroying', 'isDestroyed', 'query', 'isUpdating', 'isLoaded', 'meta', 'links', 'isAsync', 'isPolymorphic', 'identifier', 'cache', '_inverseIsAsync', 'key', 'DEPRECATED_CLASS_NAME'];
 class IdentifierArray {
   /**
     The flag to signal a `RecordArray` is currently loading data.
@@ -3307,6 +3449,7 @@ class IdentifierArray {
     // we track all mutations within the call
     // and forward them as one
     let _SIGNAL = null;
+    const extensions = options.field && this.store.schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions ? this.store.schema.CAUTION_MEGA_DANGER_ZONE_arrayExtensions(options.field) : null;
     const proxy = new NativeProxy(this[SOURCE], {
       get(target, prop, receiver) {
         const index = convertToInt(prop);
@@ -3404,10 +3547,21 @@ class IdentifierArray {
           }
           return consumeInternalSignal(_SIGNAL), outcome;
         }
+        if (isExtensionProp(extensions, prop)) {
+          return performArrayExtensionGet(receiver, extensions, signals, prop, _SIGNAL, boundFns, v => void (transaction = v));
+        }
         return target[prop];
       },
       // FIXME: Should this get a generic like get above?
       set(target, prop, value, receiver) {
+        if (!options.allowMutation && !MUTABLE_PROPS.includes(prop)) {
+          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+            if (!test) {
+              throw new Error(`Mutating ${String(prop)} on this Array is not allowed.`);
+            }
+          })(options.allowMutation) : {};
+          return false;
+        }
         if (prop === 'length') {
           if (!transaction && value === 0) {
             transaction = true;
@@ -3432,6 +3586,9 @@ class IdentifierArray {
           PrivateState.meta = value || null;
           return true;
         }
+        if (isExtensionProp(extensions, prop)) {
+          return performExtensionSet(receiver, extensions, signals, prop, value);
+        }
         const index = convertToInt(prop);
 
         // we do not allow "holey" arrays and so if the index is
@@ -3458,14 +3615,6 @@ class IdentifierArray {
           }
           return false;
         }
-        if (!options.allowMutation) {
-          macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-            if (!test) {
-              throw new Error(`Mutating ${String(prop)} on this Array is not allowed.`);
-            }
-          })(options.allowMutation) : {};
-          return false;
-        }
         const original = target[index];
         const newIdentifier = extractIdentifierFromRecord$2(value);
         macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
@@ -6953,6 +7102,11 @@ function getPromise(promise) {
  *
  */
 function getPromiseState(promise) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error(`getPromiseState expects to be called with a promise: called with ${String(promise)}`);
+    }
+  })(promise) : {};
   const _promise = getPromise(promise);
   let state = PromiseCache.get(_promise);
   if (!state) {
@@ -6961,6 +7115,619 @@ function getPromiseState(promise) {
   }
   return state;
 }
+function decorateMethodV2(prototype, prop, decorators) {
+  const origDesc = Object.getOwnPropertyDescriptor(prototype, prop);
+  let desc = {
+    ...origDesc
+  };
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer !== void 0) {
+    desc.value = desc.initializer ? desc.initializer.call(prototype) : void 0;
+    desc.initializer = void 0;
+  }
+  Object.defineProperty(prototype, prop, desc);
+}
+const DEFAULT_DEADLINE = 30_000;
+const DISPOSE = Symbol.dispose || Symbol.for('dispose');
+function isNeverString(val) {
+  return val;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+/**
+ * A reactive class
+ *
+ * @hideconstructor
+ */
+class RequestSubscription {
+  /**
+   * Whether the browser reports that the network is online.
+   */
+
+  /**
+   * Whether the browser reports that the tab is hidden.
+   */
+
+  /**
+   * Whether the component is currently refreshing the request.
+   */
+
+  /**
+   * The most recent blocking request that was made, typically
+   * the result of a reload.
+   *
+   * This will never be the original request passed as an arg to
+   * the component.
+   *
+   * @internal
+   */
+
+  /**
+   * The most recent request that was made, typically due to either a
+   * reload or a refresh.
+   *
+   * This will never be the original request passed as an arg to
+   * the component.
+   *
+   * @internal
+   */
+
+  /**
+   * The time at which the network was reported as offline.
+   *
+   * @internal
+   */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /**
+   * The event listener for network status changes,
+   * cached to use the reference for removal.
+   *
+   * @internal
+   */
+
+  /**
+   * The event listener for visibility status changes,
+   * cached to use the reference for removal.
+   *
+   * @internal
+   */
+
+  /**
+   * The last request passed as an arg to the component,
+   * cached for comparison.
+   *
+   * @internal
+   */
+
+  /**
+   * The last query passed as an arg to the component,
+   * cached for comparison.
+   *
+   * @internal
+   */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  constructor(store, args) {
+    this._args = args;
+    this.store = store;
+    this._subscribedTo = null;
+    this._subscription = null;
+    this._intervalStart = null;
+    this._invalidated = false;
+    this._nextInterval = null;
+    this.isDestroyed = false;
+    this._installListeners();
+    void this._beginPolling();
+  }
+
+  /**
+   * @internal
+   */
+  async _beginPolling() {
+    // await the initial request
+    try {
+      if (!this.isIdle) {
+        await this.request;
+      }
+    } catch {
+      // ignore errors here, we just want to wait for the request to finish
+    } finally {
+      if (!this.isDestroyed) {
+        void this._scheduleInterval();
+      }
+    }
+  }
+  get isIdle() {
+    const {
+      request,
+      query
+    } = this._args;
+    return Boolean(!request && !query);
+  }
+  static {
+    decorateMethodV2(this.prototype, "isIdle", [memoized]);
+  }
+  get autorefreshTypes() {
+    const {
+      autorefresh
+    } = this._args;
+    let types;
+    if (autorefresh === true) {
+      types = ['online', 'invalid'];
+    } else if (typeof autorefresh === 'string') {
+      types = autorefresh.split(',');
+    } else {
+      types = [];
+    }
+    return new Set(types);
+  }
+
+  // we only run this function on component creation
+  // and when an update is triggered, so it does not
+  // react to changes in the autorefreshThreshold
+  // or autorefresh args.
+  //
+  // if we need to react to those changes, we can
+  // use a modifier or internal component or some
+  // such to trigger a re-run of this function.
+  static {
+    decorateMethodV2(this.prototype, "autorefreshTypes", [memoized]);
+  }
+  async _scheduleInterval() {
+    const {
+      autorefreshThreshold
+    } = this._args;
+    const hasValidThreshold = typeof autorefreshThreshold === 'number' && autorefreshThreshold > 0;
+    if (
+    // dont schedule in SSR
+    typeof window === 'undefined' ||
+    // dont schedule without a threshold
+    !hasValidThreshold ||
+    // dont schedule if we weren't told to
+    !this.autorefreshTypes.has('interval') ||
+    // dont schedule if we're already scheduled
+    this._intervalStart !== null) {
+      return;
+    }
+
+    // if we have a current request, wait for it to finish
+    // before scheduling the next one
+    if (this._latestRequest) {
+      try {
+        await this._latestRequest;
+      } catch {
+        // ignore errors here, we just want to wait for the request to finish
+      }
+      if (this.isDestroyed) {
+        return;
+      }
+    }
+
+    // setup the next interval
+    this._intervalStart = Date.now();
+    this._nextInterval = setTimeout(() => {
+      this._maybeUpdate();
+    }, autorefreshThreshold);
+  }
+  _clearInterval() {
+    if (this._nextInterval) {
+      clearTimeout(this._nextInterval);
+      this._intervalStart = null;
+    }
+  }
+  /**
+   * @internal
+   */
+  _updateSubscriptions() {
+    if (this.isIdle) {
+      return;
+    }
+    const requestId = this._request.lid;
+
+    // if we're already subscribed to this request, we don't need to do anything
+    if (this._subscribedTo === requestId) {
+      return;
+    }
+
+    // if we're subscribed to a different request, we need to unsubscribe
+    this._removeSubscriptions();
+
+    // if we have a request, we need to subscribe to it
+    const {
+      store
+    } = this;
+    if (requestId && isStore(store)) {
+      this._subscribedTo = requestId;
+      this._subscription = store.notifications.subscribe(requestId, (_id, op) => {
+        // ignore subscription events that occur while our own component's request
+        // is ocurring
+        if (this._isUpdating) {
+          return;
+        }
+        switch (op) {
+          case 'invalidated':
+            {
+              // if we're subscribed to invalidations, we need to update
+              if (this.autorefreshTypes.has('invalid')) {
+                this._invalidated = true;
+                this._maybeUpdate();
+              }
+              break;
+            }
+          case 'state':
+            {
+              const latest = store.requestManager._deduped.get(requestId);
+              const priority = latest?.priority;
+              const state = this.reqState;
+              if (!priority) {
+                // if there is no priority, we have completed whatever request
+                // was occurring and so we are no longer refreshing (if we were)
+                this.isRefreshing = false;
+              } else if (priority.blocking && !state.isLoading) {
+                // if we are blocking, there is an active request for this identity
+                // that MUST be fulfilled from network (not cache).
+                // Thus this is not "refreshing" because we should clear out and
+                // block on this request.
+                //
+                // we receive state notifications when either a request initiates
+                // or completes.
+                //
+                // In the completes case: we may receive the state notification
+                // slightly before the request is finalized because the NotificationManager
+                // may sync flush it (and thus deliver it before the microtask completes)
+                //
+                // In the initiates case: we aren't supposed to receive one unless there
+                // is no other request in flight for this identity.
+                //
+                // However, there is a race condition here where the completed
+                // notification can trigger an update that generates a new request
+                // thus giving us an initiated notification before the older request
+                // finalizes.
+                //
+                // When this occurs, if the triggered update happens to have caused
+                // a new request to be made for the same identity AND that request
+                // is the one passed into this component as the @request arg, then
+                // getRequestState will return the state of the new request.
+                // We can detect this by checking if the request state is "loading"
+                // as outside of this case we would have a completed request.
+                //
+                // That is the reason for the `&& !state.isLoading` check above.
+
+                // TODO should we just treat this as refreshing?
+                this.isRefreshing = false;
+                this._maybeUpdate('policy', true);
+              } else {
+                this.isRefreshing = true;
+              }
+            }
+        }
+      });
+    }
+  }
+
+  /**
+   * @internal
+   */
+  _removeSubscriptions() {
+    if (this._subscription && isStore(this.store)) {
+      this.store.notifications.unsubscribe(this._subscription);
+      this._subscribedTo = null;
+      this._subscription = null;
+    }
+  }
+
+  /**
+   * Install the event listeners for network and visibility changes.
+   * This is only done in browser environments with a global `window`.
+   *
+   * @internal
+   */
+  _installListeners() {
+    if (typeof window === 'undefined') {
+      return;
+    }
+    this.isOnline = window.navigator.onLine;
+    this._unavailableStart = this.isOnline ? null : Date.now();
+    this.isHidden = document.visibilityState === 'hidden';
+    this._onlineChanged = event => {
+      this.isOnline = event.type === 'online';
+      if (event.type === 'offline' && this._unavailableStart === null) {
+        this._unavailableStart = Date.now();
+      }
+      this._maybeUpdate();
+    };
+    this._backgroundChanged = () => {
+      const isHidden = document.visibilityState === 'hidden';
+      this.isHidden = isHidden;
+      if (isHidden && this._unavailableStart === null) {
+        this._unavailableStart = Date.now();
+      }
+      this._maybeUpdate();
+    };
+    window.addEventListener('online', this._onlineChanged, {
+      passive: true,
+      capture: true
+    });
+    window.addEventListener('offline', this._onlineChanged, {
+      passive: true,
+      capture: true
+    });
+    document.addEventListener('visibilitychange', this._backgroundChanged, {
+      passive: true,
+      capture: true
+    });
+  }
+
+  /**
+   * If the network is online and the tab is visible, either reload or refresh the request
+   * based on the component's configuration and the requested update mode.
+   *
+   * Valid modes are:
+   *
+   * - `'reload'`: Force a reload of the request.
+   * - `'refresh'`: Refresh the request in the background.
+   * - `'policy'`: Make the request, letting the store's configured CachePolicy decide whether to reload, refresh, or do nothing.
+   * - `undefined`: Make the request using the component's autorefreshBehavior setting if the autorefreshThreshold has passed.
+   *
+   * @internal
+   */
+  _maybeUpdate(mode, silent) {
+    if (this.isIdle) {
+      return;
+    }
+    const canAttempt = Boolean(this.isOnline && !this.isHidden && (mode || this.autorefreshTypes.size));
+    if (!canAttempt) {
+      if (!silent && mode && mode !== '_invalidated') {
+        throw new Error(`Reload not available: the network is not online or the tab is hidden`);
+      }
+      return;
+    }
+    const {
+      autorefreshTypes
+    } = this;
+    let shouldAttempt = this._invalidated || Boolean(mode);
+    if (!shouldAttempt && autorefreshTypes.has('online')) {
+      const {
+        _unavailableStart
+      } = this;
+      const {
+        autorefreshThreshold
+      } = this._args;
+      const deadline = typeof autorefreshThreshold === 'number' ? autorefreshThreshold : DEFAULT_DEADLINE;
+      shouldAttempt = Boolean(_unavailableStart && Date.now() - _unavailableStart > deadline);
+    }
+    if (!shouldAttempt && autorefreshTypes.has('interval')) {
+      const {
+        _intervalStart
+      } = this;
+      const {
+        autorefreshThreshold
+      } = this._args;
+      if (_intervalStart && typeof autorefreshThreshold === 'number' && autorefreshThreshold > 0) {
+        shouldAttempt = Boolean(Date.now() - _intervalStart >= autorefreshThreshold);
+      }
+    }
+    this._unavailableStart = null;
+    this._invalidated = false;
+    if (shouldAttempt) {
+      this._clearInterval();
+      const request = Object.assign({}, this.reqState.request);
+      const realMode = mode === '_invalidated' ? null : mode;
+      const val = realMode ?? this._args.autorefreshBehavior ?? 'policy';
+      switch (val) {
+        case 'reload':
+          request.cacheOptions = Object.assign({}, request.cacheOptions, {
+            reload: true
+          });
+          break;
+        case 'refresh':
+          request.cacheOptions = Object.assign({}, request.cacheOptions, {
+            backgroundReload: true
+          });
+          break;
+        case 'policy':
+          break;
+        default:
+          throw new Error(`Invalid ${mode ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val)}`);
+      }
+      const wasStoreRequest = request[EnableHydration] === true;
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot supply a different store than was used to create the request`);
+        }
+      })(!request.store || request.store === this.store) : {};
+      const store = request.store || this.store;
+      const requester = wasStoreRequest && 'requestManager' in store ? store.requestManager : store;
+      this._isUpdating = true;
+      this._latestRequest = requester.request(request);
+      if (val !== 'refresh') {
+        this._localRequest = this._latestRequest;
+      }
+      void this._scheduleInterval();
+      void this._latestRequest.finally(() => {
+        this._isUpdating = false;
+      });
+    }
+  }
+
+  /**
+   * Retry the request, reloading it from the server.
+   */
+  retry = async () => {
+    this._maybeUpdate('reload');
+    await this._localRequest;
+  };
+
+  /**
+   * Refresh the request, updating it in the background.
+   */
+  refresh = async () => {
+    this._maybeUpdate('refresh');
+    await this._latestRequest;
+  };
+
+  /**
+   * features to yield to the error slot of a component
+   */
+  get errorFeatures() {
+    return {
+      isHidden: this.isHidden,
+      isOnline: this.isOnline,
+      retry: this.retry
+    };
+  }
+
+  /**
+   * features to yield to the content slot of a component
+   */
+  static {
+    decorateMethodV2(this.prototype, "errorFeatures", [memoized]);
+  }
+  get contentFeatures() {
+    const feat = {
+      isHidden: this.isHidden,
+      isOnline: this.isOnline,
+      reload: this.retry,
+      refresh: this.refresh,
+      isRefreshing: this.isRefreshing,
+      latestRequest: this._latestRequest
+    };
+    if (feat.isRefreshing) {
+      feat.abort = () => {
+        this._latestRequest?.abort();
+      };
+    }
+    return feat;
+  }
+
+  /**
+   * The method to call when the component this subscription is attached to
+   * unmounts.
+   */
+  static {
+    decorateMethodV2(this.prototype, "contentFeatures", [memoized]);
+  }
+  [DISPOSE]() {
+    this.isDestroyed = true;
+    this._removeSubscriptions();
+    if (typeof window === 'undefined') {
+      return;
+    }
+    this._clearInterval();
+    window.removeEventListener('online', this._onlineChanged, {
+      passive: true,
+      capture: true
+    });
+    window.removeEventListener('offline', this._onlineChanged, {
+      passive: true,
+      capture: true
+    });
+    document.removeEventListener('visibilitychange', this._backgroundChanged, {
+      passive: true,
+      capture: true
+    });
+  }
+
+  /**
+   * @internal
+   */
+  get _request() {
+    const {
+      request,
+      query
+    } = this._args;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot use both @request and @query args with the <Request> component`);
+      }
+    })(!request || !query) : {};
+    const {
+      _localRequest,
+      _originalRequest,
+      _originalQuery
+    } = this;
+    const isOriginalRequest = request === _originalRequest && query === _originalQuery;
+    if (_localRequest && isOriginalRequest) {
+      return _localRequest;
+    }
+
+    // update state checks for the next time
+    this._originalQuery = query;
+    this._originalRequest = request;
+    if (request) {
+      return request;
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You must provide either @request or an @query arg with the <Request> component`);
+      }
+    })(query) : {};
+    // @ts-expect-error TODO investigate this
+    return this.store.request(query);
+  }
+  static {
+    decorateMethodV2(this.prototype, "_request", [memoized]);
+  }
+  get request() {
+    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+      try {
+        const request = this._request;
+        this._updateSubscriptions();
+        return request;
+      } catch (e) {
+        // eslint-disable-next-line no-console
+        console.log(e);
+        throw new Error(`Unable to initialize the request`, {
+          cause: e
+        });
+      }
+    } else {
+      const request = this._request;
+      this._updateSubscriptions();
+      return request;
+    }
+  }
+  static {
+    decorateMethodV2(this.prototype, "request", [memoized]);
+  }
+  get reqState() {
+    return getRequestState(this.request);
+  }
+  get result() {
+    return this.reqState.result;
+  }
+}
+defineSignal(RequestSubscription.prototype, 'isOnline', true);
+defineSignal(RequestSubscription.prototype, 'isHidden', false);
+defineSignal(RequestSubscription.prototype, 'isRefreshing', false);
+defineSignal(RequestSubscription.prototype, '_localRequest', undefined);
+defineSignal(RequestSubscription.prototype, '_latestRequest', undefined);
+function isStore(store) {
+  return 'requestManager' in store;
+}
+function createRequestSubscription(store, args) {
+  return new RequestSubscription(store, args);
+}
 const RequestCache = new WeakMap();
 function isAbortError(error) {
   return error instanceof DOMException && error.name === 'AbortError';
@@ -7355,4 +8122,4 @@ function getRequestState(future) {
   }
   return state;
 }
-export { peekInternalSignal as A, withSignalStore as B, Collection as C, notifyInternalSignal as D, consumeInternalSignal as E, getOrCreateInternalSignal as F, ReactiveDocument as G, setIdentifierGenerationMethod as H, IdentifierArray as I, setIdentifierUpdateMethod as J, setIdentifierForgetMethod as K, setIdentifierResetMethod as L, MUTATE as M, setKeyInfoForResource as N, RecordArrayManager as R, Store as S, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, SOURCE as d, ensureStringId as e, fastPush as f, removeRecordDataFor as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, setCacheFor as k, RelatedCollection as l, log as m, normalizeModelName as n, logGroup as o, peekCache as p, getPromiseState as q, recordIdentifierFor as r, storeFor as s, getRequestState as t, memoized as u, gate as v, entangleSignal as w, defineSignal as x, defineNonEnumerableSignal as y, Signals as z };
+export { Signals as A, peekInternalSignal as B, Collection as C, DISPOSE as D, withSignalStore as E, notifyInternalSignal as F, consumeInternalSignal as G, getOrCreateInternalSignal as H, IdentifierArray as I, ReactiveDocument as J, setIdentifierGenerationMethod as K, setIdentifierUpdateMethod as L, MUTATE as M, setIdentifierForgetMethod as N, setIdentifierResetMethod as O, setKeyInfoForResource as P, isExtensionProp as Q, RecordArrayManager as R, Store as S, performExtensionSet as T, performArrayExtensionGet as U, performObjectExtensionGet as V, _clearCaches as _, isDocumentIdentifier as a, coerceId as b, constructResource as c, SOURCE as d, ensureStringId as e, fastPush as f, removeRecordDataFor as g, setRecordIdentifier as h, isStableIdentifier as i, StoreMap as j, setCacheFor as k, RelatedCollection as l, log as m, normalizeModelName as n, logGroup as o, peekCache as p, getPromiseState as q, recordIdentifierFor as r, storeFor as s, createRequestSubscription as t, getRequestState as u, memoized as v, gate as w, entangleSignal as x, defineSignal as y, defineNonEnumerableSignal as z };