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

package/dist/unpkg/prod/reactive/-private.js

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

package/dist/unpkg/prod/reactive.js

@@ -1,10 +1,8 @@
-export { N as SchemaService, K as checkout, T as commit, p as createRequestSubscription, P as fromIdentity, U as getPromiseState, q as getRequestState, L as instantiateRecord, Q as registerDerivations, M as teardownRecord, O as withDefaults } from "./index-D4si_DxB.js";
-export { a as Checkout } from "./symbols-sql1_mdx.js";
-import './types/request.js';
-import '@embroider/macros';
-import '@ember/debug';
-import './utils/string.js';
-import "./configure-C3x8YXzL.js";
+export { S as SchemaService, c as checkout, a as commit, b as createRequestSubscription, f as fromIdentity, d as getPromiseState, g as getRequestState, r as registerDerivations, w as withDefaults } from "./promise-state-ipG60SdD.js";
+export { i as instantiateRecord, t as teardownRecord } from "./hooks-BfiqDg3O.js";
+export { C as Checkout } from "./-private-3C1OkYtZ.js";
+import './types/-private.js';
+import './types/runtime.js';
 const Subscriptions = new WeakMap();
 
 /**

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

@@ -0,0 +1,437 @@
+import { STRUCTURED, IS_FUTURE } from './types/request.js';
+import { getOrSetUniversal, getOrSetGlobal } from './types/-private.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 PromiseCache = getOrSetUniversal('PromiseCache', new WeakMap());
+const RequestMap = getOrSetUniversal('RequestMap', new Map());
+function setRequestResult(requestId, result) {
+  RequestMap.set(requestId, result);
+}
+function clearRequestResult(requestId) {
+  RequestMap.delete(requestId);
+}
+function getRequestResult(requestId) {
+  return RequestMap.get(requestId);
+}
+function setPromiseResult(promise, result) {
+  PromiseCache.set(promise, result);
+}
+function getPromiseResult(promise) {
+  return PromiseCache.get(promise);
+}
+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, clearRequestResult as a, getPromiseResult as b, cloneResponseProperties as c, withResponseType as d, executeNextHandler as e, withReactiveResponse as f, getRequestResult as g, createDeferred as h, setPromiseResult as s, upgradePromise as u, withBrand as w };

package/dist/unpkg/prod/request.js

@@ -1 +1 @@
-export { i as createDeferred, g as getPromiseResult, s as setPromiseResult, w as withBrand, h as withReactiveResponse, f as withResponseType } from "./request-oqoLC9rz.js";
+export { h as createDeferred, b as getPromiseResult, s as setPromiseResult, w as withBrand, f as withReactiveResponse, d as withResponseType } from "./request-CN2LxbYX.js";

package/dist/unpkg/prod/store/-private.js

@@ -1,2 +1,127 @@
-export { C as CacheHandler, D as DISPOSE, R as RecordArrayManager, B as Signals, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, I as consumeInternalSignal, F as createInternalMemo, l as createLegacyManyArray, p as createRequestSubscription, z as defineGate, A as defineNonEnumerableSignal, y as defineSignal, e as ensureStringId, x as entangleInitiallyStaleSignal, w as entangleSignal, f as fastPush, v as gate, J as getOrCreateInternalSignal, q as getRequestState, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, u as memoized, H as notifyInternalSignal, E as peekInternalSignal, r as recordIdentifierFor, j as setRecordIdentifier, t as signal, s as storeFor, G as withSignalStore } from "../index-D4si_DxB.js";
-export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "../configure-C3x8YXzL.js";
+import '../types/-private.js';
+export { C as CacheHandler, S as Store, a as assertPrivateStore, i as isPrivateStore } from "../handler-LAyD1Y5l.js";
+import { m as isResourceKey, n as coerceId } from "../promise-state-ipG60SdD.js";
+export { D as DISPOSE, q as RecordArrayManager, J as Signals, x as StoreMap, _ as _clearCaches, y as _deprecatingNormalize, u as assertPrivateCapabilities, O as consumeInternalSignal, L as createInternalMemo, z as createLegacyManyArray, b as createRequestSubscription, H as defineGate, I as defineNonEnumerableSignal, G as defineSignal, p as ensureStringId, F as entangleInitiallyStaleSignal, E as entangleSignal, t as fastPush, C as gate, P as getOrCreateInternalSignal, g as getRequestState, o as isRequestKey, B as memoized, N as notifyInternalSignal, K as peekInternalSignal, e as recordIdentifierFor, v as setRecordIdentifier, A as signal, s as storeFor, M as withSignalStore } from "../promise-state-ipG60SdD.js";
+export { A as ARRAY_SIGNAL, O as OBJECT_SIGNAL, w as waitFor } from "../configure-C0C1LpG6.js";
+const TEXT_COLORS = {
+  TEXT: 'inherit',
+  notify: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  'reactive-ui': ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  graph: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  request: ['white', 'white', 'inherit', 'magenta', 'inherit'],
+  cache: ['white', 'white', 'inherit', 'magenta', 'inherit']
+};
+const BG_COLORS = {
+  TEXT: 'transparent',
+  notify: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  'reactive-ui': ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  graph: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  request: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent'],
+  cache: ['dimgray', 'cadetblue', 'transparent', 'transparent', 'transparent']
+};
+const NOTIFY_BORDER = {
+  TEXT: 0,
+  notify: [3, 2, 0, 0, 0],
+  'reactive-ui': [3, 2, 0, 0, 0],
+  graph: [3, 2, 0, 0, 0],
+  request: [3, 2, 0, 0, 0],
+  cache: [3, 2, 0, 0, 0]
+};
+const LIGHT_DARK_ALT = {
+  lightgreen: 'green',
+  green: 'lightgreen'
+};
+function badge(isLight, color, bgColor, border) {
+  return [`color: ${correctColor(isLight, color)}; background-color: ${correctColor(isLight, bgColor)}; padding: ${border}px ${2 * border}px; border-radius: ${border}px;`, `color: ${TEXT_COLORS.TEXT}; background-color: ${BG_COLORS.TEXT};`];
+}
+function colorForBucket(isLight, scope, bucket) {
+  if (scope === 'request') {
+    return bucket === 'blocking' ? badge(isLight, 'red', 'transparent', 0) : bucket === 'cached' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'non-blocking' ? badge(isLight, 'orange', 'transparent', 0) : badge(isLight, 'gray', 'transparent', 0);
+  }
+  if (scope === 'notify') {
+    return bucket === 'added' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  if (scope === 'reactive-ui') {
+    return bucket === 'created' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'disconnected' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  if (scope === 'cache') {
+    return bucket === 'inserted' ? badge(isLight, 'lightgreen', 'transparent', 0) : bucket === 'removed' ? badge(isLight, 'red', 'transparent', 0) : badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]);
+  }
+  return badge(isLight, TEXT_COLORS[scope][3], BG_COLORS[scope][3], NOTIFY_BORDER[scope][3]);
+}
+function logGroup(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  // eslint-disable-next-line no-console
+  console.groupCollapsed(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+}
+function log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  // eslint-disable-next-line no-console
+  console.log(..._log(scope, prefix, subScop1, subScop2, subScop3, subScop4));
+}
+function correctColor(isLight, color) {
+  if (!isLight) {
+    return color;
+  }
+  return color in LIGHT_DARK_ALT ? LIGHT_DARK_ALT[color] : color;
+}
+function isLightMode() {
+  if (window?.matchMedia?.('(prefers-color-scheme: light)').matches) {
+    return true;
+  }
+  return false;
+}
+function _log(scope, prefix, subScop1, subScop2, subScop3, subScop4) {
+  const isLight = isLightMode();
+  switch (scope) {
+    case 'request':
+    case 'reactive-ui':
+    case 'notify':
+      {
+        const scopePath = prefix ? `[${prefix}] ${scope}` : scope;
+        const path = subScop4 ? `${subScop3}.${subScop4}` : subScop3;
+        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${path}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, path)];
+      }
+    case 'cache':
+      {
+        const scopePath = prefix ? `${scope} (${prefix})` : scope;
+        return [`%c@warp%c-%cdrive%c %c${scopePath}%c %c${subScop1}%c %c${subScop2}%c %c${subScop3}%c %c${subScop4}%c`, ...badge(isLight, 'lightgreen', 'transparent', 0), ...badge(isLight, 'magenta', 'transparent', 0), ...badge(isLight, TEXT_COLORS[scope][0], BG_COLORS[scope][0], NOTIFY_BORDER[scope][0]), ...badge(isLight, TEXT_COLORS[scope][1], BG_COLORS[scope][1], NOTIFY_BORDER[scope][1]), ...badge(isLight, TEXT_COLORS[scope][2], BG_COLORS[scope][2], NOTIFY_BORDER[scope][2]), ...colorForBucket(isLight, scope, subScop3), ...badge(isLight, TEXT_COLORS[scope][4], BG_COLORS[scope][4], NOTIFY_BORDER[scope][4])];
+      }
+  }
+  return [];
+}
+function isNonEmptyString(str) {
+  return Boolean(str && typeof str === 'string');
+}
+function constructResource(type, id, lid) {
+  if (typeof type === 'object' && type !== null) {
+    const resource = type;
+    if (isResourceKey(resource)) {
+      return resource;
+    }
+    if ('id' in resource) {
+      resource.id = coerceId(resource.id);
+    }
+    return resource;
+  } else {
+    const trueId = coerceId(id);
+    if (!isNonEmptyString(trueId)) {
+      if (isNonEmptyString(lid)) {
+        return {
+          lid
+        };
+      }
+      throw new Error('Expected either id or lid to be a valid string');
+    }
+    if (isNonEmptyString(lid)) {
+      return {
+        type,
+        id: trueId,
+        lid
+      };
+    }
+    return {
+      type,
+      id: trueId
+    };
+  }
+}
+export { coerceId, constructResource, isResourceKey, log, logGroup };