@warp-drive/core 5.8.0-alpha.3 → 5.8.0-alpha.32

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

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

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

@@ -0,0 +1,2 @@
+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";

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

@@ -0,0 +1 @@
+export { D as DefaultCachePolicy, p as parseCacheControl } from "./default-cache-policy-D7_u4YRH.js";

package/dist/unpkg/prod-deprecated/symbols-sql1_mdx.js

@@ -0,0 +1,39 @@
+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 { Context as C, Destroy as D, SOURCE as S, Checkout as a, Commit as b };

package/dist/unpkg/prod-deprecated/types/-private.js

@@ -0,0 +1,79 @@
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+const name = "@warp-drive/core";
+const version = "5.8.0-alpha.32";
+
+// in testing mode, we utilize globals to ensure only one copy exists of
+// these maps, due to bugs in ember-auto-import
+
+const GlobalRef = globalThis;
+const UniversalCache = GlobalRef.__warpDrive_universalCache = GlobalRef.__warpDrive_universalCache ?? {};
+
+// in order to support mirror packages, we ensure that each
+// unique package name has its own global cache
+GlobalRef[name] = GlobalRef[name] ?? {
+  __version: version
+};
+const GlobalSink = GlobalRef[name];
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+  if (GlobalSink.__version !== version) {
+    throw new Error('Multiple versions of WarpDrive detected, the application will malfunction.');
+  }
+}
+const ModuleScopedCaches = GlobalSink.__warpDrive_ModuleScopedCaches ?? {};
+if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+  if (!GlobalSink.__warpDrive_ModuleScopedCaches) {
+    GlobalSink.__warpDrive_ModuleScopedCaches = ModuleScopedCaches;
+  } else {
+    // eslint-disable-next-line no-console
+    console.warn(`
+Multiple copies of WarpDrive have been detected. This may be due to a bug in ember-auto-import
+  in which test assets get their own copy of some v2-addons. This can cause the application to
+  malfunction as each copy will maintain its own separate state.`);
+  }
+} else {
+  if (GlobalSink.__warpDrive_hasOtherCopy) {
+    throw new Error('Multiple copies of WarpDrive detected, the application will malfunction.');
+  }
+  GlobalSink.__warpDrive_hasOtherCopy = true;
+}
+function getOrSetGlobal(key, value) {
+  if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+    const existing = ModuleScopedCaches[key];
+    if (existing === undefined) {
+      return ModuleScopedCaches[key] = value;
+    } else {
+      return existing;
+    }
+  } else {
+    return value;
+  }
+}
+function peekTransient(key) {
+  const globalKey = `(transient) ${key}`;
+  return ModuleScopedCaches[globalKey] ?? null;
+}
+function setTransient(key, value) {
+  const globalKey = `(transient) ${key}`;
+  return ModuleScopedCaches[globalKey] = value;
+}
+function getOrSetUniversal(key, value) {
+  if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+    const existing = UniversalCache[key];
+    if (existing === undefined) {
+      return UniversalCache[key] = value;
+    } else {
+      return existing;
+    }
+  } else {
+    return value;
+  }
+}
+function peekUniversalTransient(key) {
+  const globalKey = `(transient) ${key}`;
+  return UniversalCache[globalKey] ?? null;
+}
+function setUniversalTransient(key, value) {
+  const globalKey = `(transient) ${key}`;
+  return UniversalCache[globalKey] = value;
+}
+export { getOrSetGlobal, getOrSetUniversal, peekTransient, peekUniversalTransient, setTransient, setUniversalTransient };

package/dist/unpkg/prod-deprecated/types/identifier.js

@@ -0,0 +1,63 @@
+import { macroCondition, getGlobalConfig } from '@embroider/macros';
+
+// provided for additional debuggability
+const DEBUG_CLIENT_ORIGINATED = Symbol('record-originated-on-client');
+const DEBUG_KEY_TYPE = Symbol('key-type');
+const DEBUG_STALE_CACHE_OWNER = Symbol('warpDriveStaleCache');
+function ProdSymbol(str, debugStr) {
+  return macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? Symbol(debugStr) : str;
+}
+
+// also present in production
+const CACHE_OWNER = ProdSymbol('__$co', 'CACHE_OWNER');
+
+/**
+ * A referentially stable object with a unique string (lid) that can be used
+ * as a reference to request data in the cache.
+ *
+ * Only requests that are assigned a RequestKey are retrievable/replayable from
+ * the cache, though requests without RequestKeys may still update cache state.
+ *
+ * @public
+ */
+
+/** @deprecated use {@link RequestKey} */
+
+/**
+ * Used when an ResourceKey is known to be the stable version
+ */
+
+/**
+ * Used when a ResourceKey was not created locally as part
+ * of a call to store.createRecord
+ *
+ * Distinguishing between this ResourceKey and one for a client created
+ * resource that was created with an ID is generally speaking not possible
+ * at runtime, so anything with an ID typically narrows to this.
+ */
+
+/** @deprecated use {@link PersistedResourceKey} */
+
+/**
+ * Used when a ResourceKey was created locally
+ * (by a call to store.createRecord).
+ *
+ * It is possible in rare circumstances to have a ResourceKey
+ * that is not for a new record but does not have an ID. This would
+ * happen if a user intentionally created one for use with a secondary-index
+ * prior to the record having been fully loaded.
+ */
+
+/**
+ * A referentially stable object with a unique string (lid) that can be used
+ * as a reference to data in the cache.
+ *
+ * Every resource has a unique ResourceKey, and ResourceKeys may refer
+ * to data that has never been loaded (for instance, in an async relationship).
+ *
+ * @public
+ */
+
+/** @deprecated use {@link ResourceKey} */
+
+export { CACHE_OWNER, DEBUG_CLIENT_ORIGINATED, DEBUG_KEY_TYPE, DEBUG_STALE_CACHE_OWNER };

package/dist/unpkg/prod-deprecated/types/record.js

@@ -0,0 +1,191 @@
+/**
+ * Records may be anything, They don't even
+ * have to be objects.
+ *
+ * Whatever they are, if they have a Type
+ * property, that property will be used by WarpDrive
+ * and WarpDrive to provide better type safety and
+ * intellisense.
+ *
+ * @class TypedRecordInstance
+ */
+
+/**
+ * A type utility that extracts the Type if available,
+ * otherwise it returns never.
+ *
+ */
+
+/**
+ * A type utility that extracts the Type if available,
+ * otherwise it returns string
+ *
+ */
+
+/**
+ * A Utility that extracts either resource types or resource paths from a TypedRecordInstance.
+ *
+ * Its limitations are mostly around its intentional non-recursiveness. It presumes that APIs which
+ * implement includes will not allow cyclical include paths, and will collapse includes by type.
+ *
+ * This follows closer to the JSON:API fields spec than to the includes spec in nature, but in
+ * practice it is so impracticle for an API to allow z-algo include paths that this is probably
+ * reasonable.
+ *
+ * We may need to revisit this in the future, opting to either make this restriction optional or
+ * to allow for other strategies.
+ *
+ * There's a 90% chance this particular implementation belongs being in the JSON:API package instead
+ * of core-types, but it's here for now.
+ *
+ */
+
+/**
+ * A utility that provides the union of all ResourceName for all potential
+ * includes for the given TypedRecordInstance.
+ *
+ */
+
+// ToPaths<ExpandIgnore<T, true>, false>;
+
+/**
+ * A utility that provides the union type of all valid include paths for the given
+ * TypedRecordInstance.
+ *
+ * Cyclical paths are filtered out.
+ *
+ */
+
+function createIncludeValidator() {
+  return function validateIncludes(includes) {
+    return includes;
+  };
+}
+
+/**
+ * A utility that takes two types, K and T, and produces a new type that is a "mask" of T based on K.
+ *
+ * That's a mouthful, so let's break it down:
+ *
+ * Let's say you have a User type and an Address type.
+ *
+ * ```ts
+ * interface Address {
+ *   street: string;
+ *   city: string;
+ *   state: string;
+ *   zip: string;
+ * }
+ *
+ * interface User {
+ *   name: string;
+ *   title: string;
+ *   address: Address;
+ * }
+ * ```
+ *
+ * Now, imagine you want to load a preview of the user with some information about their address,
+ * but you don't want to load the entire user or address. You probably want to still ensure
+ * the type of the data you do load matches the underlying Address and User types, but doesn't
+ * include everything.
+ *
+ * If you did this manually, you might do something like this:
+ *
+ * ```ts
+ * interface UserPreview {
+ *   name: string;
+ *   address: AddressPreview;
+ * }
+ *
+ * interface AddressPreview {
+ *   city: string;
+ * }
+ * ```
+ *
+ * From a TypeScript performance perspective, this is the best way to approach these preview
+ * types, but this is also tedious and error-prone, especially if the User or Address types change.
+ *
+ * For Address, we could create a validated type using `Pick`:
+ *
+ * ```ts
+ * type AddressPreview = Pick<Address, 'city'>;
+ * ```
+ *
+ * This ensures that if the Address type changes, our AddressPreview will still be valid.
+ * However, for UserPreview, we can't just use `Pick` because the `address` property is of type `Address`,
+ * not `AddressPreview`. This is where the `Mask` type comes in.
+ *
+ * With `Mask`, we define the `UserPreview` in two parts
+ * - first, we define the subset of fields we want to include from `User`, using `Pick` or an interface.
+ * - then, we use `Mask` to replace the related types of fields like Address with their more limited subset.
+ *
+ * Here's how we can do it:
+ *
+ * ```ts
+ * // First, we define the base of UserPreview with Pick
+ * type UserPreviewBase = Pick<User, 'name' | 'address'>;
+ * // Then, we use Mask to replace Address with AddressPreview
+ * type UserPreview = Mask<{ address: AddressPreview }, UserPreviewBase>;
+ * ```
+ *
+ * Now, `UserPreview` will have the `name` field from `User` and the `address` field will be of type `AddressPreview`.
+ * This way, if the `User` or `Address` types change, TypeScript will ensure that our `UserPreview` and `AddressPreview`
+ * types remain valid and consistent with the underlying types.
+ *
+ * But what if your app has data with massive interfaces such that the TypeScript performance of this
+ * approach becomes a problem? In that case, see {@link Validate}
+ */
+
+/**
+ * A utility that takes two types, K and T, and ensures that K is a valid subset of T.
+ *
+ * That's a mouthful, so let's break it down:
+ *
+ * Let's say you have a User type and an Address type.
+ *
+ * ```ts
+ * interface Address {
+ *   street: string;
+ *   city: string;
+ *   state: string;
+ *   zip: string;
+ * }
+ *
+ * interface User {
+ *   name: string;
+ *   title: string;
+ *   address: Address;
+ * }
+ * ```
+ *
+ * Now, imagine you want to load a preview of the user with some information about their address,
+ * but you don't want to load the entire user or address. You probably want to still ensure
+ * the type of the data you do load matches the underlying Address and User types, but doesn't
+ * include everything.
+ *
+ * You might do something like this:
+ *
+ * ```ts
+ * interface UserPreview {
+ *   name: string;
+ *   address: AddressPreview;
+ * }
+ *
+ * interface AddressPreview {
+ *   city: string;
+ * }
+ * ```
+ *
+ * From a TypeScript performance perspective, this is the best way to approach these preview
+ * types, but this is also error-prone, especially if the User or Address types change.
+ *
+ * Validate can help ensure that your preview types remain valid.
+ *
+ * ```ts
+ * type IsValidUserPreview = Validate<UserPreview, User>; // This will be valid
+ * ```
+ *
+ * For help creating subsets of types, see {@link Mask}
+ */
+
+export { createIncludeValidator };

package/dist/unpkg/prod-deprecated/types/request.js

@@ -0,0 +1,77 @@
+import { getOrSetUniversal, getOrSetGlobal } from './-private.js';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+const SkipCache = getOrSetUniversal('SkipCache', Symbol.for('wd:skip-cache'));
+const EnableHydration = getOrSetUniversal('EnableHydration', Symbol.for('wd:enable-hydration'));
+const IS_FUTURE = getOrSetGlobal('IS_FUTURE', Symbol('IS_FUTURE'));
+const STRUCTURED = getOrSetGlobal('DOC', Symbol('DOC'));
+
+/**
+ * Use these options to adjust {@link CacheHandler} behavior for a request
+ * via {@link RequestInfo.cacheOptions}.
+ *
+ */
+
+/**
+ * When a {@link Future} resolves, it returns an object
+ * containing the original {@link RequestInfo | request},
+ * the {@link Response | response} set by the handler chain (if any), and
+ * the processed content.
+ */
+
+/**
+ * When a {@link Future} rejects, it throws either an {@link Error}
+ * an {@link AggregateError} or a {@link DOMException} that maintains
+ * the `{ request, response, content }` shape but is also an Error instance
+ * itself.
+ *
+ * If using the error originates from the {@link Fetch | Fetch Handler}
+ * the error will be a {@link FetchError}
+ */
+
+/**
+ * A union of the resolve/reject data types for the {@link Future}
+ * returned by {@link Store.request | request}
+ *
+ * See also the docs for:
+ *
+ * - {@link Future}
+ * - {@link StructuredDataDocument} (resolved/successful requests)
+ * - {@link StructuredErrorDocument} (rejected/failed requests)
+ */
+
+/**
+ * The {@link RequestInit} interface accepted by the native {@link fetch} API.
+ *
+ * WarpDrive provides our own typings due to incompleteness in the native typings.
+ *
+ * @privateRemarks
+ * - [MDN Reference (fetch)](https://developer.mozilla.org/docs/Web/API/Window/fetch)
+ * - [MDN Reference (RequestInit)](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit)
+ * - [MDN Reference (Request)](https://developer.mozilla.org/docs/Web/API/Request)
+ *
+ */
+
+/**
+ * Extends JavaScript's native {@link fetch} {@link NativeRequestInit | RequestInit} with additional
+ * properties specific to the {@link RequestManager | RequestManager's} capabilities.
+ *
+ * This interface is used to define the shape of a request that can be made via
+ * either the {@link RequestManager.request} or {@link Store.request} methods.
+ *
+ * @privateRemarks
+ * - [MDN Reference (fetch)](https://developer.mozilla.org/docs/Web/API/Window/fetch)
+ * - [MDN Reference (RequestInit)](https://developer.mozilla.org/en-US/docs/Web/API/RequestInit)
+ * - [MDN Reference (Request)](https://developer.mozilla.org/docs/Web/API/Request)
+ *
+ * @public
+ * @since 4.12
+ */
+
+/**
+ * Immutable version of {@link RequestInfo}. This is what is passed to handlers.
+ *
+ */
+
+export { EnableHydration, IS_FUTURE, STRUCTURED, SkipCache };

package/dist/unpkg/prod-deprecated/types/runtime.js

@@ -0,0 +1,34 @@
+import { getOrSetUniversal } from './-private.js';
+const RuntimeConfig = getOrSetUniversal('WarpDriveRuntimeConfig', {
+  debug: {}
+});
+function trySessionStorage() {
+  // This works even when sessionStorage is not available.
+  // See https://github.com/warp-drive-data/warp-drive/issues/9784
+  try {
+    return globalThis.sessionStorage;
+  } catch {
+    return undefined;
+  }
+}
+const storage = trySessionStorage();
+const settings = storage?.getItem('WarpDriveRuntimeConfig');
+if (settings) {
+  Object.assign(RuntimeConfig, JSON.parse(settings));
+}
+function getRuntimeConfig() {
+  return RuntimeConfig;
+}
+
+/**
+ * Upserts the specified logging configuration into the runtime
+ * config.
+ *
+ * globalThis.setWarpDriveLogging({ LOG_CACHE: true } });
+ *
+ */
+function setLogging(config) {
+  Object.assign(RuntimeConfig.debug, config);
+  storage?.setItem('WarpDriveRuntimeConfig', JSON.stringify(RuntimeConfig));
+}
+export { getRuntimeConfig, setLogging };