@warp-drive-mirror/core 5.9.0-alpha.2 → 5.9.0-alpha.21

package/dist/unpkg/prod-deprecated/-private-3C1OkYtZ.js

@@ -1,39 +0,0 @@
-import { getOrSetGlobal } from './types/-private.js';
-
-///////////////////
-///// WARNING /////
-///////////////////
-
-// Great, got your attention with that warning didn't we?
-// Good. Here's the deal: typescript treats symbols as unique types.
-// If by accident a module creating a symbol is processed more than
-// once, the symbol will be different in each processing. This will
-// cause a type error.
-// It could also cause a runtime error if the symbol is used innapropriately.
-// However, this case is extremely hard to hit and would require other things
-// to go wrong first.
-//
-// So, why do the warning? And why do we lie about the types of the symbols?
-//
-// Because we intentionally create multiple copies of them within the types
-// at build time. This is because we rollup our d.ts files in order to give
-// our consumers a better experience.
-//
-// However, no tool today supports rolling up d.ts files with multiple entry
-// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor
-// which creates a fully unique stand-alone types file per-entry-point. Thus
-// every entry point that uses one of these symbols somewhere will have accidentally
-// created a new symbol type.
-//
-// This cast allows us to rollup these types using this tool while not encountering
-// the unique symbol type issue.
-//
-// Note that none of these symbols are part of the public API, these are used for
-// debugging DX and as a safe way to provide an intimate contract on public objects.
-
-const SOURCE = getOrSetGlobal('SOURCE', Symbol('#source'));
-const Destroy = getOrSetGlobal('Destroy', Symbol.dispose || Symbol.for('Dispose'));
-const Checkout = getOrSetGlobal('Checkout', Symbol('Checkout'));
-const Commit = getOrSetGlobal('Commit', Symbol('Commit'));
-const Context = getOrSetGlobal('Context', Symbol('Context'));
-export { Checkout as C, Destroy as D, SOURCE as S, Context as a, Commit as b };

package/dist/unpkg/prod-deprecated/handler-BVKoq9bM.js

@@ -1,334 +0,0 @@
-import { v as createReactiveDocument } from "./schema-_W00LRDb.js";
-import { SkipCache, EnableHydration } from './types/request.js';
-const MUTATION_OPS = new Set(['createRecord', 'updateRecord', 'deleteRecord']);
-function calcShouldFetch(store, request, hasCachedValue, identifier) {
-  const {
-    cacheOptions
-  } = request;
-  return request.op && MUTATION_OPS.has(request.op) || cacheOptions?.reload || !hasCachedValue || (store.lifetimes && identifier ? store.lifetimes.isHardExpired(identifier, store) : false);
-}
-function calcShouldBackgroundFetch(store, request, willFetch, identifier) {
-  const {
-    cacheOptions
-  } = request;
-  return cacheOptions?.backgroundReload || (store.lifetimes && identifier ? store.lifetimes.isSoftExpired(identifier, store) : false);
-}
-function isMutation(request) {
-  return Boolean(request.op && MUTATION_OPS.has(request.op));
-}
-function isCacheAffecting(document) {
-  if (!isMutation(document.request)) {
-    return true;
-  }
-  // a mutation combined with a 204 has no cache impact when no known records were involved
-  // a createRecord with a 201 with an empty response and no known records should similarly
-  // have no cache impact
-
-  if (document.request.op === 'createRecord' && document.response?.status === 201) {
-    return document.content ? Object.keys(document.content).length > 0 : false;
-  }
-  return document.response?.status !== 204;
-}
-function isAggregateError(error) {
-  return error instanceof AggregateError || error.name === 'AggregateError' && Array.isArray(error.errors);
-}
-// TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
-function cloneError(error) {
-  const isAggregate = isAggregateError(error);
-  const cloned = isAggregate ? new AggregateError(structuredClone(error.errors), error.message) : new Error(error.message);
-  cloned.stack = error.stack;
-  cloned.error = error.error;
-
-  // copy over enumerable properties
-  Object.assign(cloned, error);
-  return cloned;
-}
-function getPriority(identifier, deduped, priority) {
-  if (identifier) {
-    const existing = deduped.get(identifier);
-    if (existing) {
-      return existing.priority;
-    }
-  }
-  return priority;
-}
-
-/**
- * A CacheHandler that adds support for using an WarpDrive Cache with a RequestManager.
- *
- * This handler will only run when a request has supplied a `store` instance. Requests
- * issued by the store via `store.request()` will automatically have the `store` instance
- * attached to the request.
- *
- * ```ts
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET'
- * });
- * ```
- *
- * When this handler elects to handle a request, it will return the raw `StructuredDocument`
- * unless the request has `[EnableHydration]` set to `true`. In this case, the handler will
- * return a `Document` instance that will automatically update the UI when the cache is updated
- * in the future and will hydrate any identifiers in the StructuredDocument into Record instances.
- *
- * When issuing a request via the store, [EnableHydration] is automatically set to `true`. This
- * means that if desired you can issue requests that utilize the cache without needing to also
- * utilize Record instances if desired.
- *
- * Said differently, you could elect to issue all requests via a RequestManager, without ever using
- * the store directly, by setting [EnableHydration] to `true` and providing a store instance. Not
- * necessarily the most useful thing, but the decoupled nature of the RequestManager and incremental-feature
- * approach of WarpDrive allows for this flexibility.
- *
- * ```ts
- * import { EnableHydration } from '@warp-drive-mirror/core/types/request';
- *
- * requestManager.request({
- *   store: store,
- *   url: '/api/posts',
- *   method: 'GET',
- *   [EnableHydration]: true
- * });
- *
- */
-const CacheHandler = {
-  request(context, next) {
-    // if we have no cache or no cache-key skip cache handling
-    if (!context.request.store || context.request.cacheOptions?.[SkipCache]) {
-      return next(context.request);
-    }
-    const {
-      store
-    } = context.request;
-    const identifier = store.cacheKeyManager.getOrCreateDocumentIdentifier(context.request);
-    if (identifier) {
-      context.setIdentifier(identifier);
-    }
-
-    // used to dedupe existing requests that match
-    const DEDUPE = store.requestManager._deduped;
-    const activeRequest = identifier && DEDUPE.get(identifier);
-    const peeked = identifier ? store.cache.peekRequest(identifier) : null;
-
-    // determine if we should skip cache
-    if (calcShouldFetch(store, context.request, !!peeked, identifier)) {
-      if (activeRequest) {
-        activeRequest.priority = {
-          blocking: true
-        };
-        return activeRequest.promise;
-      }
-      let promise = fetchContentAndHydrate(next, context, identifier, {
-        blocking: true
-      });
-      if (identifier) {
-        promise = promise.finally(() => {
-          DEDUPE.delete(identifier);
-          store.notifications.notify(identifier, 'state', null);
-        });
-        DEDUPE.set(identifier, {
-          priority: {
-            blocking: true
-          },
-          promise
-        });
-        queueMicrotask(() => {
-          store.notifications.notify(identifier, 'state', null);
-        });
-      }
-      store.requestManager._pending.set(context.id, promise);
-      return promise;
-    }
-
-    // if we have not skipped cache, determine if we should update behind the scenes
-    if (calcShouldBackgroundFetch(store, context.request, false, identifier)) {
-      let promise = activeRequest?.promise || fetchContentAndHydrate(next, context, identifier, {
-        blocking: false
-      });
-      if (identifier && !activeRequest) {
-        promise = promise.finally(() => {
-          DEDUPE.delete(identifier);
-          store.notifications.notify(identifier, 'state', null);
-        });
-        DEDUPE.set(identifier, {
-          priority: {
-            blocking: false
-          },
-          promise
-        });
-        queueMicrotask(() => {
-          store.notifications.notify(identifier, 'state', null);
-        });
-      }
-      store.requestManager._pending.set(context.id, promise);
-    }
-    const shouldHydrate = context.request[EnableHydration] || false;
-    context.setResponse(peeked.response);
-    if ('error' in peeked) {
-      const content = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-        shouldHydrate,
-        identifier
-      }, peeked.content) : peeked.content;
-      const newError = cloneError(peeked);
-      newError.content = content;
-      throw newError;
-    }
-    const result = shouldHydrate ? maybeUpdateUiObjects(store, context.request, {
-      shouldHydrate,
-      identifier
-    }, peeked.content) : peeked.content;
-    return result;
-  }
-};
-function maybeUpdateUiObjects(store, request, options, document) {
-  const {
-    identifier
-  } = options;
-  if (!document || !options.shouldHydrate) {
-    return document ?? null;
-  }
-  if (identifier) {
-    return store._instanceCache.getDocument(identifier);
-  }
-
-  // if we don't have an identifier, we give the document
-  // its own local cache
-  return createReactiveDocument(store, null, {
-    request,
-    document
-  });
-}
-function updateCacheForSuccess(store, request, options, document) {
-  let response = null;
-  if (isMutation(request)) {
-    if (Array.isArray(request.records)) {
-      response = store.cache.didCommit(request.records, document);
-    } else if (request.data?.record) {
-      // legacy fallback, the data option should no longer be used for this
-      response = store.cache.didCommit(request.data.record, document);
-
-      // a mutation combined with a 204 has no cache impact when no known records were involved
-      // a createRecord with a 201 with an empty response and no known records should similarly
-      // have no cache impact
-    } else if (isCacheAffecting(document)) {
-      response = store.cache.put(document);
-    }
-  } else {
-    response = store.cache.put(document);
-  }
-  return maybeUpdateUiObjects(store, request, options, response);
-}
-function handleFetchSuccess(store, context, options, document) {
-  const {
-    request
-  } = context;
-  store.requestManager._pending.delete(context.id);
-  store._enableAsyncFlush = true;
-  let response;
-  store._join(() => {
-    response = updateCacheForSuccess(store, request, options, document);
-  });
-  store._enableAsyncFlush = null;
-  if (store.lifetimes?.didRequest) {
-    store.lifetimes.didRequest(context.request, document.response, options.identifier, store);
-  }
-  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
-  if (finalPriority.blocking) {
-    return response;
-  } else {
-    store.notifications._flush();
-  }
-}
-function updateCacheForError(store, context, options, error) {
-  let response;
-  if (isMutation(context.request)) {
-    // TODO similar to didCommit we should spec this to be similar to cache.put for handling full response
-    // currently we let the response remain undefiend.
-    const errors = error && error.content && typeof error.content === 'object' && 'errors' in error.content && Array.isArray(error.content.errors) ? error.content.errors : undefined;
-    if (Array.isArray(context.request.records)) {
-      store.cache.commitWasRejected(context.request.records, errors);
-    } else if (context.request.data?.record) {
-      // legacy fallback, the data option should no longer be used for this
-      store.cache.commitWasRejected(context.request.data.record, errors);
-    } else {
-      store.cache.put(error);
-    }
-  } else {
-    response = store.cache.put(error);
-    return maybeUpdateUiObjects(store, context.request, options, response);
-  }
-}
-function handleFetchError(store, context, options, error) {
-  store.requestManager._pending.delete(context.id);
-  if (context.request.signal?.aborted) {
-    throw error;
-  }
-  store._enableAsyncFlush = true;
-  let response;
-  store._join(() => {
-    response = updateCacheForError(store, context, options, error);
-  });
-  store._enableAsyncFlush = null;
-  if (options.identifier && store.lifetimes?.didRequest) {
-    store.lifetimes.didRequest(context.request, error.response, options.identifier, store);
-  }
-  if (isMutation(context.request)) {
-    throw error;
-  }
-  const finalPriority = getPriority(options.identifier, store.requestManager._deduped, options.priority);
-  if (finalPriority.blocking) {
-    const newError = cloneError(error);
-    newError.content = response;
-    throw newError;
-  } else {
-    store.notifications._flush();
-  }
-}
-function fetchContentAndHydrate(next, context, identifier, priority) {
-  const {
-    store
-  } = context.request;
-  const shouldHydrate = context.request[EnableHydration] || false;
-  const options = {
-    shouldHydrate,
-    identifier,
-    priority
-  };
-  let isMut = false;
-  if (isMutation(context.request)) {
-    isMut = true;
-    if (Array.isArray(context.request.records)) {
-      context.request.records.forEach(record => {
-        store.cache.willCommit(record, context);
-      });
-    } else if (context.request.data?.record) {
-      // legacy fallback, the data option should no longer be used for this
-      store.cache.willCommit(context.request.data.record, context);
-    }
-  }
-  if (store.lifetimes?.willRequest) {
-    store.lifetimes.willRequest(context.request, identifier, store);
-  }
-  const promise = next(context.request).then(document => {
-    return handleFetchSuccess(store, context, options, document);
-  }, error => {
-    return handleFetchError(store, context, options, error);
-  });
-  if (!isMut) {
-    return promise;
-  }
-
-  // for mutations we need to enqueue the promise with the requestStateService
-  // TODO should we enque a request per record in records?
-  const record = context.request.data?.record || context.request.records?.[0];
-  return store._requestCache._enqueue(promise, {
-    data: [{
-      op: 'saveRecord',
-      recordIdentifier: record,
-      options: undefined
-    }]
-  });
-}
-export { CacheHandler as C };

package/dist/unpkg/prod-deprecated/hooks-CfCFjO7d.js

@@ -1,26 +0,0 @@
-import { u as ReactiveResource } from "./schema-_W00LRDb.js";
-import { D as Destroy } from "./-private-3C1OkYtZ.js";
-function instantiateRecord(store, identifier, createArgs) {
-  const schema = store.schema;
-  const resourceSchema = schema.resource(identifier);
-  const legacy = resourceSchema?.legacy ?? false;
-  const editable = legacy;
-  const record = new ReactiveResource({
-    store,
-    resourceKey: identifier,
-    modeName: legacy ? 'legacy' : 'polaris',
-    legacy: legacy,
-    editable: editable,
-    path: null,
-    field: null,
-    value: null
-  });
-  if (createArgs && editable) {
-    Object.assign(record, createArgs);
-  }
-  return record;
-}
-function teardownRecord(record) {
-  record[Destroy]();
-}
-export { instantiateRecord as i, teardownRecord as t };

package/dist/unpkg/prod-deprecated/promise-cache-DIT8Ypjq.js

@@ -1,19 +0,0 @@
-import { getOrSetUniversal } from './types/-private.js';
-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);
-}
-export { setRequestResult as a, getPromiseResult as b, clearRequestResult as c, getRequestResult as g, setPromiseResult as s };