@warp-drive/ember 0.0.0-alpha.8 → 0.0.0-alpha.81

package/dist/index.js

@@ -0,0 +1,1138 @@
+import { tracked, cached } from '@glimmer/tracking';
+import { getPromiseResult, setPromiseResult } from '@ember-data/request';
+import { service } from '@ember/service';
+import Component from '@glimmer/component';
+import { macroCondition, moduleExists, importSync, getGlobalConfig } from '@embroider/macros';
+import { EnableHydration } from '@warp-drive/core-types/request';
+import { precompileTemplate } from '@ember/template-compilation';
+import { setComponentTemplate } from '@ember/component';
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  c: () => decorateClass,
+  f: () => decorateFieldV1,
+  g: () => decorateFieldV2,
+  i: () => initializeDeferredDecorator,
+  m: () => decorateMethodV1,
+  n: () => decorateMethodV2,
+  p: () => decoratePOJO
+});
+var deferred = /* @__PURE__ */new WeakMap();
+function deferDecorator(proto, prop, desc) {
+  let map = deferred.get(proto);
+  if (!map) {
+    map = /* @__PURE__ */new Map();
+    deferred.set(proto, map);
+  }
+  map.set(prop, desc);
+}
+function findDeferredDecorator(target, prop) {
+  let cursor = target.prototype;
+  while (cursor) {
+    let desc = deferred.get(cursor)?.get(prop);
+    if (desc) {
+      return desc;
+    }
+    cursor = cursor.prototype;
+  }
+}
+function decorateFieldV1(target, prop, decorators, initializer) {
+  return decorateFieldV2(target.prototype, prop, decorators, initializer);
+}
+function decorateFieldV2(prototype, prop, decorators, initializer) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: null
+  };
+  if (initializer) {
+    desc.initializer = initializer;
+  }
+  for (let decorator of decorators) {
+    desc = decorator(prototype, prop, desc) || desc;
+  }
+  if (desc.initializer === void 0) {
+    Object.defineProperty(prototype, prop, desc);
+  } else {
+    deferDecorator(prototype, prop, desc);
+  }
+}
+function decorateMethodV1({
+  prototype
+}, prop, decorators) {
+  return decorateMethodV2(prototype, prop, decorators);
+}
+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);
+}
+function initializeDeferredDecorator(target, prop) {
+  let desc = findDeferredDecorator(target.constructor, prop);
+  if (desc) {
+    Object.defineProperty(target, prop, {
+      enumerable: desc.enumerable,
+      configurable: desc.configurable,
+      writable: desc.writable,
+      value: desc.initializer ? desc.initializer.call(target) : void 0
+    });
+  }
+}
+function decorateClass(target, decorators) {
+  return decorators.reduce((accum, decorator) => decorator(accum) || accum, target);
+}
+function decoratePOJO(pojo, decorated) {
+  for (let [type, prop, decorators] of decorated) {
+    if (type === "field") {
+      decoratePojoField(pojo, prop, decorators);
+    } else {
+      decorateMethodV2(pojo, prop, decorators);
+    }
+  }
+  return pojo;
+}
+function decoratePojoField(pojo, prop, decorators) {
+  let desc = {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    initializer: () => Object.getOwnPropertyDescriptor(pojo, prop)?.value
+  };
+  for (let decorator of decorators) {
+    desc = decorator(pojo, prop, desc) || desc;
+  }
+  if (desc.initializer) {
+    desc.value = desc.initializer.call(pojo);
+    delete desc.initializer;
+  }
+  Object.defineProperty(pojo, prop, desc);
+}
+const RequestCache = new WeakMap();
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === 'AbortError';
+}
+async function watchStream(stream, state) {
+  const reader = stream.getReader();
+  let bytesLoaded = 0;
+  let shouldForward = state._stream !== null && state._stream.readable.locked;
+  let isForwarding = shouldForward;
+  let writer = state._stream?.writable.getWriter();
+  const buffer = [];
+  state._isPending = false;
+  state._isStarted = true;
+  state._startTime = performance.now();
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const {
+      value,
+      done
+    } = await reader.read();
+    if (done) {
+      break;
+    }
+    bytesLoaded += value.byteLength;
+    state._bytesLoaded = bytesLoaded;
+    state._lastPacketTime = performance.now();
+    shouldForward = shouldForward || state._stream !== null && state._stream.readable.locked;
+    if (shouldForward) {
+      if (!isForwarding) {
+        isForwarding = true;
+        writer = state._stream.writable.getWriter();
+        for (const item of buffer) {
+          await writer.ready;
+          await writer.write(item);
+        }
+        buffer.length = 0;
+      }
+      await writer.ready;
+      await writer.write(value);
+    } else {
+      buffer.push(value);
+    }
+  }
+
+  // if we are still forwarding, we need to close the writer
+  if (isForwarding) {
+    await writer.ready;
+    await writer.close();
+  } else if (state._stream) {
+    // if we are not forwarding, we need to cancel the stream
+    await state._stream.readable.cancel('The Stream Has Already Ended');
+    state._stream = null;
+  }
+  const endTime = performance.now();
+  state._endTime = endTime;
+  state._isComplete = true;
+  state._isStarted = false;
+}
+class RequestLoadingState {
+  _stream = null;
+  _future;
+  _triggered = false;
+  _trigger() {
+    if (this._triggered) {
+      return;
+    }
+    this._triggered = true;
+    const future = this._future;
+    const promise = future.getStream();
+    if (promise.sizeHint) {
+      this._sizeHint = promise.sizeHint;
+    }
+    this.promise = promise.then(stream => {
+      if (!stream) {
+        this._isPending = false;
+        this._isComplete = true;
+        return;
+      }
+      return watchStream(stream, this);
+    }, error => {
+      this._isPending = false;
+      this._isStarted = false;
+      if (isAbortError(error)) {
+        this._isCancelled = true;
+        this._isComplete = true;
+      }
+      this._isErrored = true;
+      this._error = error;
+    });
+  }
+  promise = null;
+  static {
+    decorateFieldV2(this.prototype, "_sizeHint", [tracked], function () {
+      return 0;
+    });
+  }
+  #_sizeHint = (initializeDeferredDecorator(this, "_sizeHint"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_bytesLoaded", [tracked], function () {
+      return 0;
+    });
+  }
+  #_bytesLoaded = (initializeDeferredDecorator(this, "_bytesLoaded"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_startTime", [tracked], function () {
+      return 0;
+    });
+  }
+  #_startTime = (initializeDeferredDecorator(this, "_startTime"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_endTime", [tracked], function () {
+      return 0;
+    });
+  }
+  #_endTime = (initializeDeferredDecorator(this, "_endTime"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_lastPacketTime", [tracked], function () {
+      return 0;
+    });
+  }
+  #_lastPacketTime = (initializeDeferredDecorator(this, "_lastPacketTime"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_isPending", [tracked], function () {
+      return true;
+    });
+  }
+  #_isPending = (initializeDeferredDecorator(this, "_isPending"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_isStarted", [tracked], function () {
+      return false;
+    });
+  }
+  #_isStarted = (initializeDeferredDecorator(this, "_isStarted"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_isComplete", [tracked], function () {
+      return false;
+    });
+  }
+  #_isComplete = (initializeDeferredDecorator(this, "_isComplete"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_isCancelled", [tracked], function () {
+      return false;
+    });
+  }
+  #_isCancelled = (initializeDeferredDecorator(this, "_isCancelled"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_isErrored", [tracked], function () {
+      return false;
+    });
+  }
+  #_isErrored = (initializeDeferredDecorator(this, "_isErrored"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "_error", [tracked], function () {
+      return null;
+    });
+  }
+  #_error = (initializeDeferredDecorator(this, "_error"), void 0);
+  get isPending() {
+    this._trigger();
+    return this._isPending;
+  }
+  get sizeHint() {
+    this._trigger();
+    return this._sizeHint;
+  }
+  get stream() {
+    this._trigger();
+    if (!this._stream) {
+      if (this._isComplete || this._isCancelled || this._isErrored) {
+        return null;
+      }
+      this._stream = new TransformStream();
+    }
+    return this._stream.readable;
+  }
+  get isStarted() {
+    this._trigger();
+    return this._isStarted;
+  }
+  get bytesLoaded() {
+    this._trigger();
+    return this._bytesLoaded;
+  }
+  get startTime() {
+    this._trigger();
+    return this._startTime;
+  }
+  get endTime() {
+    this._trigger();
+    return this._endTime;
+  }
+  get lastPacketTime() {
+    this._trigger();
+    return this._lastPacketTime;
+  }
+  get isComplete() {
+    this._trigger();
+    return this._isComplete;
+  }
+  get isCancelled() {
+    this._trigger();
+    return this._isCancelled;
+  }
+  get isErrored() {
+    this._trigger();
+    return this._isErrored;
+  }
+  get error() {
+    this._trigger();
+    return this._error;
+  }
+  get elapsedTime() {
+    return (this.endTime || this.lastPacketTime) - this.startTime;
+  }
+  get completedRatio() {
+    return this.sizeHint ? this.bytesLoaded / this.sizeHint : 0;
+  }
+  get remainingRatio() {
+    return 1 - this.completedRatio;
+  }
+  get duration() {
+    return this.endTime - this.startTime;
+  }
+  get speed() {
+    // bytes per second
+    return this.bytesLoaded / (this.elapsedTime / 1000);
+  }
+  constructor(future) {
+    this._future = future;
+  }
+  abort = () => {
+    this._future.abort();
+  };
+}
+class RequestState {
+  #request;
+  #loadingState = null;
+  static {
+    decorateFieldV2(this.prototype, "result", [tracked], function () {
+      return null;
+    });
+  }
+  #result = (initializeDeferredDecorator(this, "result"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "error", [tracked], function () {
+      return null;
+    });
+  }
+  #error = (initializeDeferredDecorator(this, "error"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "isLoading", [tracked], function () {
+      return true;
+    });
+  }
+  #isLoading = (initializeDeferredDecorator(this, "isLoading"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "isSuccess", [tracked], function () {
+      return false;
+    });
+  }
+  #isSuccess = (initializeDeferredDecorator(this, "isSuccess"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "isError", [tracked], function () {
+      return false;
+    });
+  }
+  #isError = (initializeDeferredDecorator(this, "isError"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "request", [tracked], function () {
+      return null;
+    });
+  }
+  #request_ = (initializeDeferredDecorator(this, "request"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "response", [tracked], function () {
+      return null;
+    });
+  }
+  #response = (initializeDeferredDecorator(this, "response"), void 0);
+  get isCancelled() {
+    return this.isError && isAbortError(this.error);
+  }
+  get loadingState() {
+    if (!this.#loadingState) {
+      this.#loadingState = new RequestLoadingState(this.#request);
+    }
+    return this.#loadingState;
+  }
+  constructor(future) {
+    this.#request = future;
+    const state = getPromiseResult(future);
+    if (state) {
+      this.request = state.result.request;
+      this.response = state.result.response;
+      this.isLoading = false;
+      if (state.isError) {
+        this.error = state.result;
+        this.isError = true;
+      } else {
+        this.result = state.result.content;
+        this.isSuccess = true;
+      }
+    } else {
+      void future.then(result => {
+        setPromiseResult(future, {
+          isError: false,
+          result
+        });
+        this.result = result.content;
+        this.isSuccess = true;
+        this.isLoading = false;
+        this.request = result.request;
+        this.response = result.response;
+      }, error => {
+        setPromiseResult(future, {
+          isError: true,
+          result: error
+        });
+        this.error = error;
+        this.isError = true;
+        this.isLoading = false;
+        this.request = error.request;
+        this.response = error.response;
+      });
+    }
+  }
+}
+function getRequestState(future) {
+  let state = RequestCache.get(future);
+  if (!state) {
+    state = new RequestState(future);
+    RequestCache.set(future, state);
+  }
+  return state;
+}
+const PromiseCache = new WeakMap();
+class PromiseState {
+  static {
+    decorateFieldV2(this.prototype, "result", [tracked], function () {
+      return null;
+    });
+  }
+  #result = (initializeDeferredDecorator(this, "result"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "error", [tracked], function () {
+      return null;
+    });
+  }
+  #error = (initializeDeferredDecorator(this, "error"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "isPending", [tracked], function () {
+      return true;
+    });
+  }
+  #isPending = (initializeDeferredDecorator(this, "isPending"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "isSuccess", [tracked], function () {
+      return false;
+    });
+  }
+  #isSuccess = (initializeDeferredDecorator(this, "isSuccess"), void 0);
+  static {
+    decorateFieldV2(this.prototype, "isError", [tracked], function () {
+      return false;
+    });
+  }
+  #isError = (initializeDeferredDecorator(this, "isError"), void 0);
+  constructor(promise) {
+    const state = getPromiseResult(promise);
+    if (state) {
+      if (state.isError) {
+        this.error = state.result;
+        this.isError = true;
+        this.isPending = false;
+      } else {
+        this.result = state.result;
+        this.isSuccess = true;
+        this.isPending = false;
+      }
+    } else {
+      void promise.then(result => {
+        setPromiseResult(promise, {
+          isError: false,
+          result
+        });
+        this.result = result;
+        this.isSuccess = true;
+        this.isPending = false;
+      }, error => {
+        setPromiseResult(promise, {
+          isError: true,
+          result: error
+        });
+        this.error = error;
+        this.isError = true;
+        this.isPending = false;
+      });
+    }
+  }
+}
+const LegacyPromiseProxy = Symbol.for('LegacyPromiseProxy');
+function isLegacyAwaitable(promise) {
+  return LegacyPromiseProxy in promise && 'promise' in promise && promise[LegacyPromiseProxy] === true;
+}
+function getPromise(promise) {
+  return isLegacyAwaitable(promise) ? promise.promise : promise;
+}
+function getPromiseState(promise) {
+  const _promise = getPromise(promise);
+  let state = PromiseCache.get(_promise);
+  if (!state) {
+    state = new PromiseState(_promise);
+    PromiseCache.set(_promise, state);
+  }
+  return state;
+}
+const and = (x1, y1) => Boolean(x1 && y1);
+class Throw extends Component {
+  constructor(owner1, args1) {
+    super(owner1, args1);
+    // this error is opaque (user supplied) so we don't validate it
+    // as an Error instance.
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw this.args.error;
+  }
+  static {
+    setComponentTemplate(precompileTemplate("", {
+      strictMode: true
+    }), this);
+  }
+}
+class Await extends Component {
+  get state() {
+    return getPromiseState(this.args.promise);
+  }
+  get error() {
+    return this.state.error;
+  }
+  get result() {
+    return this.state.result;
+  }
+  static {
+    setComponentTemplate(precompileTemplate("\n    {{#if this.state.isPending}}\n      {{yield to=\"pending\"}}\n    {{else if (and this.state.isError (has-block \"error\"))}}\n      {{yield this.error to=\"error\"}}\n    {{else if this.state.isSuccess}}\n      {{yield this.result to=\"success\"}}\n    {{else}}\n      <Throw @error={{this.error}} />\n    {{/if}}\n  ", {
+      strictMode: true,
+      scope: () => ({
+        and,
+        Throw
+      })
+    }), this);
+  }
+}
+function notNull(x1) {
+  macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+    if (!test) {
+      throw new Error('Expected a non-null value, but got null');
+    }
+  })(x1 !== null) : {};
+  return x1;
+}
+const not = x1 => !x1;
+// default to 30 seconds unavailable before we refresh
+const DEFAULT_DEADLINE = 30_000;
+const IdleBlockMissingError = new Error('No idle block provided for <Request> component, and no query or request was provided.');
+let consume = service;
+if (macroCondition(moduleExists('ember-provide-consume-context'))) {
+  const {
+    consume: contextConsume
+  } = importSync('ember-provide-consume-context');
+  consume = contextConsume;
+}
+function isNeverString(val1) {
+  return val1;
+}
+/**
+ * The `<Request>` component is a powerful tool for managing data fetching and
+ * state in your Ember application. It provides declarative reactive control-flow
+ * for managing requests and state in your application.
+ *
+ * @typedoc
+ */
+class Request extends Component {
+  static {
+    decorateFieldV2(this.prototype, "_store", [consume('store')]);
+  }
+  #_store = (initializeDeferredDecorator(this, "_store"), void 0);
+  /**
+  * The store instance to use for making requests. If contexts are available, this
+  * will be the `store` on the context, else it will be the store service.
+  *
+  * @internal
+  */
+  static {
+    decorateFieldV2(this.prototype, "isOnline", [tracked], function () {
+      return true;
+    });
+  }
+  #isOnline = (initializeDeferredDecorator(this, "isOnline"), void 0);
+  /**
+  * Whether the browser reports that the network is online.
+  *
+  * @internal
+  */
+  static {
+    decorateFieldV2(this.prototype, "isHidden", [tracked], function () {
+      return true;
+    });
+  }
+  #isHidden = (initializeDeferredDecorator(this, "isHidden"), void 0);
+  /**
+  * Whether the browser reports that the tab is hidden.
+  *
+  * @internal
+  */
+  static {
+    decorateFieldV2(this.prototype, "isRefreshing", [tracked], function () {
+      return false;
+    });
+  }
+  #isRefreshing = (initializeDeferredDecorator(this, "isRefreshing"), void 0);
+  /**
+  * Whether the component is currently refreshing the request.
+  *
+  * @internal
+  */
+  static {
+    decorateFieldV2(this.prototype, "_localRequest", [tracked]);
+  }
+  #_localRequest = (initializeDeferredDecorator(this, "_localRequest"), void 0);
+  /**
+  * 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
+  */
+  static {
+    decorateFieldV2(this.prototype, "_latestRequest", [tracked]);
+  }
+  #_latestRequest = (initializeDeferredDecorator(this, "_latestRequest"), void 0);
+  /**
+  * 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
+  */
+  unavailableStart;
+  intervalStart;
+  nextInterval;
+  invalidated;
+  isUpdating;
+  /**
+  * The event listener for network status changes,
+  * cached to use the reference for removal.
+  *
+  * @internal
+  */
+  onlineChanged;
+  /**
+  * The event listener for visibility status changes,
+  * cached to use the reference for removal.
+  *
+  * @internal
+  */
+  backgroundChanged;
+  /**
+  * The last request passed as an arg to the component,
+  * cached for comparison.
+  *
+  * @internal
+  */
+  _originalRequest;
+  /**
+  * The last query passed as an arg to the component,
+  * cached for comparison.
+  *
+  * @internal
+  */
+  _originalQuery;
+  _subscription;
+  _subscribedTo;
+  constructor(owner1, args1) {
+    super(owner1, args1);
+    this._subscribedTo = null;
+    this._subscription = null;
+    this.intervalStart = null;
+    this.invalidated = false;
+    this.nextInterval = null;
+    this.installListeners();
+    void this.beginPolling();
+  }
+  async beginPolling() {
+    // await the initial request
+    try {
+      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: request1,
+      query: query1
+    } = this.args;
+    return Boolean(!request1 && !query1);
+  }
+  static {
+    decorateMethodV2(this.prototype, "isIdle", [cached]);
+  }
+  get autorefreshTypes() {
+    const {
+      autorefresh: autorefresh1
+    } = this.args;
+    let types1;
+    if (autorefresh1 === true) {
+      types1 = ['online', 'invalid'];
+    } else if (typeof autorefresh1 === 'string') {
+      types1 = autorefresh1.split(',');
+    } else {
+      types1 = [];
+    }
+    return new Set(types1);
+  }
+  // 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", [cached]);
+  }
+  async scheduleInterval() {
+    const {
+      autorefreshThreshold: autorefreshThreshold1
+    } = this.args;
+    const hasValidThreshold1 = typeof autorefreshThreshold1 === 'number' && autorefreshThreshold1 > 0;
+    if (
+    // dont schedule in SSR
+    typeof window === 'undefined' ||
+    // dont schedule without a threshold
+    !hasValidThreshold1 ||
+    // 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();
+    }, autorefreshThreshold1);
+  }
+  clearInterval() {
+    if (this.nextInterval) {
+      clearTimeout(this.nextInterval);
+      this.intervalStart = null;
+    }
+  }
+  updateSubscriptions() {
+    if (this.isIdle) {
+      return;
+    }
+    const requestId1 = this._request.lid;
+    // if we're already subscribed to this request, we don't need to do anything
+    if (this._subscribedTo === requestId1) {
+      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
+    if (requestId1) {
+      this._subscribedTo = requestId1;
+      this._subscription = this.store.notifications.subscribe(requestId1, (_id1, op1) => {
+        // ignore subscription events that occur while our own component's request
+        // is ocurring
+        if (this.isUpdating) {
+          return;
+        }
+        switch (op1) {
+          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 latest1 = this.store.requestManager._deduped.get(requestId1);
+              const priority1 = latest1?.priority;
+              if (!priority1) {
+                this.isRefreshing = false;
+              } else if (priority1.blocking) {
+                // TODO should we just treat this as refreshing?
+                this.isRefreshing = false;
+                this.maybeUpdate('policy', true);
+              } else {
+                this.isRefreshing = true;
+              }
+            }
+        }
+      });
+    }
+  }
+  removeSubscriptions() {
+    if (this._subscription) {
+      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 = event1 => {
+      this.isOnline = event1.type === 'online';
+      if (event1.type === 'offline' && this.unavailableStart === null) {
+        this.unavailableStart = Date.now();
+      }
+      this.maybeUpdate();
+    };
+    this.backgroundChanged = () => {
+      const isHidden1 = document.visibilityState === 'hidden';
+      this.isHidden = isHidden1;
+      if (isHidden1 && 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(mode1, silent1) {
+    if (this.isIdle) {
+      return;
+    }
+    const canAttempt1 = Boolean(this.isOnline && !this.isHidden && (mode1 || this.autorefreshTypes.size));
+    if (!canAttempt1) {
+      if (!silent1 && mode1 && mode1 !== 'invalidated') {
+        throw new Error(`Reload not available: the network is not online or the tab is hidden`);
+      }
+      return;
+    }
+    const {
+      autorefreshTypes: autorefreshTypes1
+    } = this;
+    let shouldAttempt1 = this.invalidated || Boolean(mode1);
+    if (!shouldAttempt1 && autorefreshTypes1.has('online')) {
+      const {
+        unavailableStart: unavailableStart1
+      } = this;
+      const {
+        autorefreshThreshold: autorefreshThreshold1
+      } = this.args;
+      const deadline1 = typeof autorefreshThreshold1 === 'number' ? autorefreshThreshold1 : DEFAULT_DEADLINE;
+      shouldAttempt1 = Boolean(unavailableStart1 && Date.now() - unavailableStart1 > deadline1);
+    }
+    if (!shouldAttempt1 && autorefreshTypes1.has('interval')) {
+      const {
+        intervalStart: intervalStart1
+      } = this;
+      const {
+        autorefreshThreshold: autorefreshThreshold1
+      } = this.args;
+      if (intervalStart1 && typeof autorefreshThreshold1 === 'number' && autorefreshThreshold1 > 0) {
+        shouldAttempt1 = Boolean(Date.now() - intervalStart1 >= autorefreshThreshold1);
+      }
+    }
+    this.unavailableStart = null;
+    this.invalidated = false;
+    if (shouldAttempt1) {
+      this.clearInterval();
+      const request1 = Object.assign({}, this.reqState.request);
+      const realMode1 = mode1 === 'invalidated' ? null : mode1;
+      const val1 = realMode1 ?? this.args.autorefreshBehavior ?? 'policy';
+      switch (val1) {
+        case 'reload':
+          request1.cacheOptions = Object.assign({}, request1.cacheOptions, {
+            reload: true
+          });
+          break;
+        case 'refresh':
+          request1.cacheOptions = Object.assign({}, request1.cacheOptions, {
+            backgroundReload: true
+          });
+          break;
+        case 'policy':
+          break;
+        default:
+          throw new Error(`Invalid ${mode1 ? 'update mode' : '@autorefreshBehavior'} for <Request />: ${isNeverString(val1)}`);
+      }
+      const wasStoreRequest1 = request1[EnableHydration] === true;
+      macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+        if (!test) {
+          throw new Error(`Cannot supply a different store via context than was used to create the request`);
+        }
+      })(!request1.store || request1.store === this.store) : {};
+      this.isUpdating = true;
+      this._latestRequest = wasStoreRequest1 ? this.store.request(request1) : this.store.requestManager.request(request1);
+      if (val1 !== 'refresh') {
+        this._localRequest = this._latestRequest;
+      }
+      void this.scheduleInterval();
+      void this._latestRequest.finally(() => {
+        this.isUpdating = false;
+      });
+    }
+  }
+  /**
+  * Retry the request, reloading it from the server.
+  *
+  * @internal
+  */
+  retry = async () => {
+    this.maybeUpdate('reload');
+    await this._localRequest;
+  };
+  /**
+  * Refresh the request, updating it in the background.
+  *
+  * @internal
+  */
+  refresh = async () => {
+    this.maybeUpdate('refresh');
+    await this._latestRequest;
+  };
+  get errorFeatures() {
+    return {
+      isHidden: this.isHidden,
+      isOnline: this.isOnline,
+      retry: this.retry
+    };
+  }
+  static {
+    decorateMethodV2(this.prototype, "errorFeatures", [cached]);
+  }
+  get contentFeatures() {
+    const feat1 = {
+      isHidden: this.isHidden,
+      isOnline: this.isOnline,
+      reload: this.retry,
+      refresh: this.refresh,
+      isRefreshing: this.isRefreshing,
+      latestRequest: this._latestRequest
+    };
+    if (feat1.isRefreshing) {
+      feat1.abort = () => {
+        this._latestRequest?.abort();
+      };
+    }
+    return feat1;
+  }
+  static {
+    decorateMethodV2(this.prototype, "contentFeatures", [cached]);
+  }
+  willDestroy() {
+    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
+    });
+  }
+  get _request() {
+    const {
+      request: request1,
+      query: query1
+    } = this.args;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Cannot use both @request and @query args with the <Request> component`);
+      }
+    })(!request1 || !query1) : {};
+    const {
+      _localRequest: _localRequest1,
+      _originalRequest: _originalRequest1,
+      _originalQuery: _originalQuery1
+    } = this;
+    const isOriginalRequest1 = request1 === _originalRequest1 && query1 === _originalQuery1;
+    if (_localRequest1 && isOriginalRequest1) {
+      return _localRequest1;
+    }
+    // update state checks for the next time
+    this._originalQuery = query1;
+    this._originalRequest = request1;
+    if (request1) {
+      return request1;
+    }
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`You must provide either @request or an @query arg with the <Request> component`);
+      }
+    })(query1) : {};
+    return this.store.request(query1);
+  }
+  static {
+    decorateMethodV2(this.prototype, "_request", [cached]);
+  }
+  get request() {
+    const request1 = this._request;
+    this.updateSubscriptions();
+    return request1;
+  }
+  static {
+    decorateMethodV2(this.prototype, "request", [cached]);
+  }
+  get store() {
+    const store1 = this.args.store || this._store;
+    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(moduleExists('ember-provide-consume-context') ? `No store was provided to the <Request> component. Either provide a store via the @store arg or via the context API provided by ember-provide-consume-context.` : `No store was provided to the <Request> component. Either provide a store via the @store arg or by registering a store service.`);
+      }
+    })(store1) : {};
+    return store1;
+  }
+  get reqState() {
+    return getRequestState(this.request);
+  }
+  get result() {
+    return this.reqState.result;
+  }
+  static {
+    setComponentTemplate(precompileTemplate("\n    {{#if (and this.isIdle (has-block \"idle\"))}}\n      {{yield to=\"idle\"}}\n    {{else if this.isIdle}}\n      <Throw @error={{IdleBlockMissingError}} />\n    {{else if this.reqState.isLoading}}\n      {{yield this.reqState.loadingState to=\"loading\"}}\n    {{else if (and this.reqState.isCancelled (has-block \"cancelled\"))}}\n      {{yield (notNull this.reqState.error) this.errorFeatures to=\"cancelled\"}}\n    {{else if (and this.reqState.isError (has-block \"error\"))}}\n      {{yield (notNull this.reqState.error) this.errorFeatures to=\"error\"}}\n    {{else if this.reqState.isSuccess}}\n      {{yield this.result this.contentFeatures to=\"content\"}}\n    {{else if (not this.reqState.isCancelled)}}\n      <Throw @error={{(notNull this.reqState.error)}} />\n    {{/if}}\n    {{yield this.reqState to=\"always\"}}\n  ", {
+      strictMode: true,
+      scope: () => ({
+        and,
+        Throw,
+        IdleBlockMissingError,
+        notNull,
+        not
+      })
+    }), this);
+  }
+}
+export { Await, Request, Throw, getPromiseState, getRequestState };