@warp-drive/ember 5.4.1-beta.1 → 5.4.1-beta.2

package/dist/index.js

@@ -1,675 +1,12 @@
-import { tracked, cached } from '@glimmer/tracking';
-import { getPromiseResult, setPromiseResult } from '@ember-data/request';
 import { service } from '@ember/service';
 import Component from '@glimmer/component';
+import { tracked, cached } from '@glimmer/tracking';
 import { macroCondition, moduleExists, importSync, getGlobalConfig } from '@embroider/macros';
+import { getPromiseState, getRequestState } from '@ember-data/store/-private';
+export { getPromiseState, getRequestState } from '@ember-data/store/-private';
 import { EnableHydration } from '@warp-drive/core-types/request';
 import { precompileTemplate } from '@ember/template-compilation';
 import { setComponentTemplate } from '@ember/component';
-const 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) {
-  var _a;
-  let cursor = target.prototype;
-  while (cursor) {
-    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
-    if (desc) {
-      return desc;
-    }
-    cursor = cursor.prototype;
-  }
-}
-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 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
-    });
-  }
-}
-
-/**
- * @module @warp-drive/ember
- */
-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();
-  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;
-}
-
-/**
- * Lazily consumes the stream of a request, providing a number of
- * reactive properties that can be used to build UIs that respond
- * to the progress of a request.
- *
- * @class RequestLoadingState
- * @public
- */
-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();
-  };
-}
-
-/**
- * RequestState extends the concept of PromiseState to provide a reactive
- * wrapper for a request `Future` which allows you write declarative code
- * around a Future's control flow.
- *
- * It is useful in both Template and JavaScript contexts, allowing you
- * to quickly derive behaviors and data from pending, error and success
- * states.
- *
- * The key difference between a Promise and a Future is that Futures provide
- * access to a stream of their content, the identity of the request (if any)
- * as well as the ability to attempt to abort the request.
- *
- * ```ts
- * interface Future<T> extends Promise<T>> {
- *   getStream(): Promise<ReadableStream>;
- *   abort(): void;
- *   lid: StableDocumentIdentifier | null;
- * }
- * ```
- *
- * These additional APIs allow us to craft even richer state experiences.
- *
- * To get the state of a request, use `getRequestState`.
- *
- * @class RequestState
- * @public
- */
-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;
-      });
-    }
-  }
-}
-
-/**
- *
- *
- * `getRequestState` can be used in both JavaScript and Template contexts.
- *
- * ```ts
- * import { getRequestState } from '@warp-drive/ember';
- *
- * const state = getRequestState(future);
- * ```
- *
- * For instance, we could write a getter on a component that updates whenever
- * the request state advances or the future changes, by combining the function
- * with the use of `@cached`
- *
- * ```ts
- * class Component {
- *   @cached
- *   get title() {
- *     const state = getRequestState(this.args.request);
- *     if (state.isPending) {
- *       return 'loading...';
- *     }
- *     if (state.isError) { return null; }
- *     return state.result.title;
- *   }
- * }
- * ```
- *
- * Or in a template as a helper:
- *
- * ```gjs
- * import { getRequestState } from '@warp-drive/ember';
- *
- * <template>
- *   {{#let (getRequestState @request) as |state|}}
- *     {{#if state.isPending}}
- *       <Spinner />
- *     {{else if state.isError}}
- *       <ErrorForm @error={{state.error}} />
- *     {{else}}
- *       <h1>{{state.result.title}}</h1>
- *     {{/if}}
- *   {{/let}}
- * </template>
- * ```
- *
- * If looking to use in a template, consider also the `<Request />` component
- * which offers a numbe of additional capabilities for requests *beyond* what
- * `RequestState` provides.
- *
- * @method getRequestState
- * @for @warp-drive/ember
- * @static
- * @public
- * @param future
- * @return {RequestState}
- */
-function getRequestState(future) {
-  let state = RequestCache.get(future);
-  if (!state) {
-    state = new RequestState(future);
-    RequestCache.set(future, state);
-  }
-  return state;
-}
-
-/**
- * @module @warp-drive/ember
- */
-const PromiseCache = new WeakMap();
-
-/**
- * PromiseState provides a reactive wrapper for a promise which allows you write declarative
- * code around a promise's control flow. It is useful in both Template and JavaScript contexts,
- * allowing you to quickly derive behaviors and data from pending, error and success states.
- *
- * ```ts
- * interface PromiseState<T = unknown, E = unknown> {
- *   isPending: boolean;
- *   isSuccess: boolean;
- *   isError: boolean;
- *   result: T | null;
- *   error: E | null;
- * }
- * ```
- *
- * To get the state of a promise, use `getPromiseState`.
- *
- * @class PromiseState
- * @public
- */
-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;
-}
-
-/**
- * Returns a reactive state-machine for the provided promise or awaitable.
- *
- * Repeat calls to `getPromiseState` with the same promise will return the same state object
- * making is safe and easy to use in templates and JavaScript code to produce reactive
- * behaviors around promises.
- *
- * `getPromiseState` can be used in both JavaScript and Template contexts.
- *
- * ```ts
- * import { getPromiseState } from '@warp-drive/ember';
- *
- * const state = getPromiseState(promise);
- * ```
- *
- * For instance, we could write a getter on a component that updates whenever
- * the promise state advances or the promise changes, by combining the function
- * with the use of `@cached`
- *
- * ```ts
- * class Component {
- *   @cached
- *   get title() {
- *     const state = getPromiseState(this.args.request);
- *     if (state.isPending) {
- *       return 'loading...';
- *     }
- *     if (state.isError) { return null; }
- *     return state.result.title;
- *   }
- * }
- * ```
- *
- * Or in a template as a helper:
- *
- * ```gjs
- * import { getPromiseState } from '@warp-drive/ember';
- *
- * <template>
- *   {{#let (getPromiseState @request) as |state|}}
- *     {{#if state.isPending}} <Spinner />
- *     {{else if state.isError}} <ErrorForm @error={{state.error}} />
- *     {{else}}
- *       <h1>{{state.result.title}}</h1>
- *     {{/if}}
- *   {{/let}}
- * </template>
- * ```
- *
- * If looking to use in a template, consider also the `<Await />` component.
- *
- * @method getPromiseState
- * @for @warp-drive/ember
- * @static
- * @public
- * @param {Promise<T> | Awaitable<T, E>} promise
- * @return {PromiseState<T, E>}
- */
-function getPromiseState(promise) {
-  const _promise = getPromise(promise);
-  let state = PromiseCache.get(_promise);
-  if (!state) {
-    state = new PromiseState(_promise);
-    PromiseCache.set(_promise, state);
-  }
-  return state;
-}
 
 /**
  * @module @warp-drive/ember
@@ -758,6 +95,70 @@ class Await extends Component {
     }), this);
   }
 }
+const 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) {
+  var _a;
+  let cursor = target.prototype;
+  while (cursor) {
+    let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
+    if (desc) {
+      return desc;
+    }
+    cursor = cursor.prototype;
+  }
+}
+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 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
+    });
+  }
+}
 
 /**
  * @module @warp-drive/ember
@@ -1560,4 +961,4 @@ class Request extends Component {
     }), this);
   }
 }
-export { Await, Request, Throw, getPromiseState, getRequestState };
+export { Await, Request, Throw };