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

package/dist/unpkg/prod/request-BrJSCG6r.js

@@ -0,0 +1,421 @@
+import { STRUCTURED, IS_FUTURE } from './types/request.js';
+import { getOrSetGlobal } from './types/-private.js';
+import { a as setRequestResult } from "./promise-cache-DIT8Ypjq.js";
+function upgradeHeaders(headers) {
+  headers.clone = () => {
+    return new Headers(headers);
+  };
+  headers.toJSON = () => {
+    return Array.from(headers);
+  };
+  return headers;
+}
+function cloneResponseProperties(response) {
+  const {
+    headers,
+    ok,
+    redirected,
+    status,
+    statusText,
+    type,
+    url
+  } = response;
+  upgradeHeaders(headers);
+  return {
+    headers: headers,
+    ok,
+    redirected,
+    status,
+    statusText,
+    type,
+    url
+  };
+}
+class ContextOwner {
+  hasSetStream = false;
+  hasSetResponse = false;
+  hasSubscribers = false;
+  stream = createDeferred();
+  response = null;
+  nextCalled = 0;
+  constructor(request, god, isRoot = false) {
+    this.isRoot = isRoot;
+    this.requestId = god.id;
+    this.controller = request.controller || god.controller;
+    this.stream.promise.sizeHint = 0;
+    if (request.controller) {
+      if (request.controller !== god.controller) {
+        god.controller.signal.addEventListener('abort', () => {
+          this.controller.abort(god.controller.signal.reason);
+        });
+      }
+      delete request.controller;
+    }
+    let enhancedRequest = Object.assign({
+      signal: this.controller.signal
+    }, request);
+    {
+      if (request.headers) {
+        upgradeHeaders(request.headers);
+      }
+    }
+    this.enhancedRequest = enhancedRequest;
+    this.request = request;
+    this.god = god;
+    this.stream.promise = this.stream.promise.then(stream => {
+      if (this.god.stream === stream && this.hasSubscribers) {
+        this.god.stream = null;
+      }
+      return stream;
+    });
+  }
+  get hasRequestedStream() {
+    return this.god.hasRequestedStream;
+  }
+  getResponse() {
+    if (this.hasSetResponse) {
+      return this.response;
+    }
+    if (this.nextCalled === 1) {
+      return this.god.response;
+    }
+    return null;
+  }
+  getStream() {
+    if (this.isRoot) {
+      this.god.hasRequestedStream = true;
+    }
+    if (!this.hasSetResponse) {
+      const hint = this.god.response?.headers?.get('content-length');
+      this.stream.promise.sizeHint = hint ? parseInt(hint, 10) : 0;
+    }
+    this.hasSubscribers = true;
+    return this.stream.promise;
+  }
+  abort(reason) {
+    this.controller.abort(reason);
+  }
+  setStream(stream) {
+    if (!this.hasSetStream) {
+      this.hasSetStream = true;
+      if (!(stream instanceof Promise)) {
+        this.god.stream = stream;
+      }
+      // @ts-expect-error
+      this.stream.resolve(stream);
+    }
+  }
+  resolveStream() {
+    this.setStream(this.nextCalled === 1 ? this.god.stream : null);
+  }
+  setResponse(response) {
+    if (this.hasSetResponse) {
+      return;
+    }
+    this.hasSetResponse = true;
+    if (response instanceof Response) {
+      // TODO potentially avoid cloning in prod
+      let responseData = cloneResponseProperties(response);
+      this.response = responseData;
+      this.god.response = responseData;
+      const sizeHint = response.headers?.get('content-length');
+      this.stream.promise.sizeHint = sizeHint ? parseInt(sizeHint, 10) : 0;
+    } else {
+      this.response = response;
+      this.god.response = response;
+    }
+  }
+}
+class Context {
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  constructor(owner, isCacheHandler) {
+    this.id = owner.requestId;
+    this.___owner = owner;
+    this.request = owner.enhancedRequest;
+    this._isCacheHandler = isCacheHandler;
+    this._finalized = false;
+  }
+  setStream(stream) {
+    this.___owner.setStream(stream);
+  }
+  setResponse(response) {
+    this.___owner.setResponse(response);
+  }
+  setIdentifier(identifier) {
+    this.___owner.god.identifier = identifier;
+  }
+  get hasRequestedStream() {
+    return this.___owner.hasRequestedStream;
+  }
+
+  /** @private */
+  _finalize() {
+    this._finalized = true;
+  }
+}
+const IS_CACHE_HANDLER = getOrSetGlobal('IS_CACHE_HANDLER', Symbol('IS_CACHE_HANDLER'));
+function curryFuture(owner, inbound, outbound) {
+  owner.setStream(inbound.getStream());
+  inbound.then(doc => {
+    const document = {
+      [STRUCTURED]: true,
+      request: owner.request,
+      response: doc.response,
+      content: doc.content
+    };
+    outbound.resolve(document);
+  }, error => {
+    if (isDoc(error)) {
+      owner.setStream(owner.god.stream);
+    }
+    if (!error || !(error instanceof Error)) {
+      try {
+        throw new Error(error ? error : `Request Rejected with an Unknown Error`);
+      } catch (e) {
+        if (error && typeof error === 'object') {
+          Object.assign(e, error);
+          e.message = error.message || `Request Rejected with an Unknown Error`;
+        }
+        error = e;
+      }
+    }
+    error[STRUCTURED] = true;
+    error.request = owner.request;
+    error.response = owner.getResponse();
+    error.error = error.error || error.message;
+    outbound.reject(error);
+  });
+  return outbound.promise;
+}
+function isDoc(doc) {
+  return doc && doc[STRUCTURED] === true;
+}
+function ensureDoc(owner, content, isError) {
+  if (isDoc(content)) {
+    return content;
+  }
+  if (isError) {
+    return {
+      [STRUCTURED]: true,
+      request: owner.request,
+      response: owner.getResponse(),
+      error: content
+    };
+  }
+  return {
+    [STRUCTURED]: true,
+    request: owner.request,
+    response: owner.getResponse(),
+    content: content
+  };
+}
+
+/**
+ * Additional properties exposed on errors thrown by the
+ * {@link Fetch | Fetch Handler}.
+ *
+ * In the case of an Abort or system/browser level issue,
+ * this extends {@link DOMException}.
+ *
+ * Else it extends from {@link AggregateError} if the
+ * response includes an array of errors, falling back
+ * to {@link Error} as its base.
+ */
+
+function enhanceReason(reason) {
+  return new DOMException(reason || 'The user aborted a request.', 'AbortError');
+}
+function handleOutcome(owner, inbound, outbound) {
+  inbound.then(content => {
+    if (owner.controller.signal.aborted) {
+      // the next function did not respect the signal, we handle it here
+      outbound.reject(enhanceReason(owner.controller.signal.reason));
+      return;
+    }
+    if (isDoc(content)) {
+      owner.setStream(owner.god.stream);
+      content = content.content;
+    }
+    const document = {
+      [STRUCTURED]: true,
+      request: owner.request,
+      response: owner.getResponse(),
+      content
+    };
+    outbound.resolve(document);
+  }, error => {
+    if (isDoc(error)) {
+      owner.setStream(owner.god.stream);
+    }
+    if (!error || !(error instanceof Error)) {
+      try {
+        throw new Error(error ? error : `Request Rejected with an Unknown Error`);
+      } catch (e) {
+        if (error && typeof error === 'object') {
+          Object.assign(e, error);
+          e.message = error.message || `Request Rejected with an Unknown Error`;
+        }
+        error = e;
+      }
+    }
+    error[STRUCTURED] = true;
+    error.request = owner.request;
+    error.response = owner.getResponse();
+    error.error = error.error || error.message;
+    outbound.reject(error);
+  });
+  return outbound.promise;
+}
+function isCacheHandler(handler, index) {
+  return index === 0 && Boolean(handler[IS_CACHE_HANDLER]);
+}
+function executeNextHandler(wares, request, i, god) {
+  const owner = new ContextOwner(request, god, i === 0);
+  function next(r) {
+    owner.nextCalled++;
+    return executeNextHandler(wares, r, i + 1, god);
+  }
+  const _isCacheHandler = isCacheHandler(wares[i], i);
+  const context = new Context(owner, _isCacheHandler);
+  let outcome;
+  try {
+    outcome = wares[i].request(context, next);
+    if (_isCacheHandler) {
+      context._finalize();
+    }
+    if (!!outcome && _isCacheHandler) {
+      if (!(outcome instanceof Promise)) {
+        setRequestResult(owner.requestId, {
+          isError: false,
+          result: ensureDoc(owner, outcome, false)
+        });
+        outcome = Promise.resolve(outcome);
+      }
+    }
+  } catch (e) {
+    if (_isCacheHandler) {
+      setRequestResult(owner.requestId, {
+        isError: true,
+        result: ensureDoc(owner, e, true)
+      });
+    }
+    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+    outcome = Promise.reject(e);
+  }
+  const future = createFuture(owner);
+  if (isFuture(outcome)) {
+    return curryFuture(owner, outcome, future);
+  }
+  return handleOutcome(owner, outcome, future);
+}
+function isFuture(maybe) {
+  return Boolean(maybe && maybe instanceof Promise && maybe[IS_FUTURE] === true);
+}
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    resolve,
+    reject,
+    promise
+  };
+}
+function upgradePromise(promise, future) {
+  promise[IS_FUTURE] = true;
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  promise.getStream = future.getStream;
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  promise.abort = future.abort;
+  // eslint-disable-next-line @typescript-eslint/unbound-method
+  promise.onFinalize = future.onFinalize;
+  promise.id = future.id;
+  promise.lid = future.lid;
+  promise.requester = future.requester;
+  return promise;
+}
+function createFuture(owner) {
+  const deferred = createDeferred();
+  let {
+    promise
+  } = deferred;
+  let cbs;
+  promise = promise.finally(() => {
+    owner.resolveStream();
+    if (cbs) {
+      cbs.forEach(cb => cb());
+    }
+  });
+  promise.onFinalize = fn => {
+    cbs = cbs || [];
+    cbs.push(fn);
+  };
+  promise[IS_FUTURE] = true;
+  promise.getStream = () => {
+    return owner.getStream();
+  };
+  promise.abort = reason => {
+    owner.abort(enhanceReason(reason));
+  };
+  promise.id = owner.requestId;
+  promise.lid = owner.god.identifier;
+  promise.requester = owner.god.requester;
+  deferred.promise = promise;
+  return deferred;
+}
+
+/**
+ * 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 { IS_CACHE_HANDLER as I, withResponseType as a, withReactiveResponse as b, cloneResponseProperties as c, createDeferred as d, executeNextHandler as e, upgradePromise as u, withBrand as w };

package/dist/unpkg/prod/request.js

@@ -0,0 +1,2 @@
+export { d as createDeferred, w as withBrand, b as withReactiveResponse, a as withResponseType } from "./request-BrJSCG6r.js";
+export { b as getPromiseResult, s as setPromiseResult } from "./promise-cache-DIT8Ypjq.js";