@warp-drive/core 5.8.0-alpha.9 → 5.8.0-beta.1

package/dist/unpkg/dev/index.js

@@ -0,0 +1,6 @@
+export { C as CacheHandler, F as Fetch, y as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, D as setIdentifierForgetMethod, A as setIdentifierGenerationMethod, E as setIdentifierResetMethod, B as setIdentifierUpdateMethod, G as setKeyInfoForResource, s as storeFor, z as useRecommendedStore } from "./index-BzcBOnw9.js";
+import "./-private-sql1_mdx.js";
+import "./-leaked-Co0EI6Go.js";
+import './store.js';
+import './types/request.js';
+import './types/runtime.js';

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

@@ -0,0 +1 @@
+export { C as Context } from "../-private-sql1_mdx.js";

package/dist/unpkg/dev/reactive.js

@@ -0,0 +1,3 @@
+export { q as SchemaService, o as checkout, x as commit, u as fromIdentity, p as instantiateRecord, v as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-BzcBOnw9.js";
+export { a as Checkout } from "./-private-sql1_mdx.js";
+export { k as createRequestSubscription, m as getPromiseState, l as getRequestState } from "./-leaked-Co0EI6Go.js";

package/dist/unpkg/dev/request.js

@@ -0,0 +1,49 @@
+export { c as createDeferred, g as getPromiseResult, s as setPromiseResult } from "./future-DFfOzSoe.js";
+
+/**
+ * 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 { withBrand, withReactiveResponse, withResponseType };

package/dist/unpkg/dev/runtime-E1M51_-O.js

@@ -0,0 +1,135 @@
+/*
+  These are the runtime implementations for the javascript macros that have
+  runtime implementations.
+
+  Not every macro has a runtime implementation, some only make sense in the
+  build and always run there.
+
+  Even when we have runtime implementations, we are still careful to emit static
+  errors during the build wherever possible, and runtime errors when necessary,
+  so that you're not surprised when you switch from runtime-mode to compile-time
+  mode.
+*/
+
+// This is here as a compile target for `getConfig` and `getOwnConfig` when
+// we're in runtime mode. This is not public API to call from your own code.
+function config(packageRoot) {
+  return runtimeConfig.packages[packageRoot];
+}
+function getGlobalConfig() {
+  return runtimeConfig.global;
+}
+const runtimeConfig = initializeRuntimeMacrosConfig();
+
+// this exists to be targeted by our babel plugin
+function initializeRuntimeMacrosConfig() {
+  return {
+    "packages": {},
+    "global": {
+      "@embroider/macros": {
+        "isTesting": false
+      },
+      "WarpDrive": {
+        "debug": {
+          "DEBUG_RELATIONSHIP_NOTIFICATIONS": false,
+          "LOG_CACHE": false,
+          "LOG_CACHE_POLICY": false,
+          "LOG_GRAPH": false,
+          "LOG_IDENTIFIERS": false,
+          "LOG_INSTANCE_CACHE": false,
+          "LOG_METRIC_COUNTS": false,
+          "LOG_MUTATIONS": false,
+          "LOG_NOTIFICATIONS": false,
+          "LOG_OPERATIONS": false,
+          "LOG_PAYLOADS": false,
+          "LOG_REACT_SIGNAL_INTEGRATION": false,
+          "LOG_REQUESTS": false,
+          "LOG_REQUEST_STATUS": false,
+          "__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": false
+        },
+        "polyfillUUID": false,
+        "includeDataAdapter": true,
+        "compatWith": "99.0",
+        "deprecations": {
+          "DEPRECATE_CATCH_ALL": false,
+          "DEPRECATE_COMPUTED_CHAINS": false,
+          "DEPRECATE_EMBER_INFLECTOR": false,
+          "DEPRECATE_LEGACY_IMPORTS": false,
+          "DEPRECATE_MANY_ARRAY_DUPLICATES": false,
+          "DEPRECATE_NON_STRICT_ID": false,
+          "DEPRECATE_NON_STRICT_TYPES": false,
+          "DEPRECATE_NON_UNIQUE_PAYLOADS": false,
+          "DEPRECATE_RELATIONSHIP_REMOTE_UPDATE_CLEARING_LOCAL_STATE": false,
+          "DEPRECATE_STORE_EXTENDS_EMBER_OBJECT": false,
+          "DEPRECATE_TRACKING_PACKAGE": false,
+          "DISABLE_7X_DEPRECATIONS": false,
+          "ENABLE_LEGACY_REQUEST_METHODS": false,
+          "ENABLE_LEGACY_SCHEMA_SERVICE": false
+        },
+        "features": {
+          "ENFORCE_STRICT_RESOURCE_FINALIZATION": false,
+          "JSON_API_CACHE_VALIDATION_ERRORS": false,
+          "SAMPLE_FEATURE_FLAG": false
+        },
+        "activeLogging": {
+          "DEBUG_RELATIONSHIP_NOTIFICATIONS": true,
+          "LOG_CACHE": true,
+          "LOG_CACHE_POLICY": true,
+          "LOG_GRAPH": true,
+          "LOG_IDENTIFIERS": true,
+          "LOG_INSTANCE_CACHE": true,
+          "LOG_METRIC_COUNTS": true,
+          "LOG_MUTATIONS": true,
+          "LOG_NOTIFICATIONS": true,
+          "LOG_OPERATIONS": true,
+          "LOG_PAYLOADS": true,
+          "LOG_REACT_SIGNAL_INTEGRATION": true,
+          "LOG_REQUESTS": true,
+          "LOG_REQUEST_STATUS": true,
+          "__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": true
+        },
+        "env": {
+          "TESTING": true,
+          "PRODUCTION": false,
+          "DEBUG": true,
+          "IS_RECORDING": false,
+          "IS_CI": true,
+          "SHOULD_RECORD": false
+        }
+      }
+    }
+  };
+}
+function updaterMethods() {
+  return {
+    config,
+    getGlobalConfig,
+    setConfig(packageRoot, value) {
+      runtimeConfig.packages[packageRoot] = value;
+    },
+    setGlobalConfig(key, value) {
+      runtimeConfig.global[key] = value;
+    }
+  };
+}
+
+// this is how runtime config can get injected at boot. I'm not sure yet if this
+// should be public API, but we certainly need it internally to set things like
+// the global fastboot.isRunning.
+//
+// consumers of this API push a function onto
+// window._embroider_macros_runtime_config. The function is given four methods
+// which allow it to read and write the per-package and global configs. The
+// reason for allowing both read & write is that merging strategies are up to
+// each consumers -- read first, then merge, then write.
+//
+// For an example user of this API, see where we generate
+// embroider_macros_fastboot_init.js' in @embroider/core.
+let updaters = typeof window !== 'undefined' ? window._embroider_macros_runtime_config : undefined;
+if (updaters) {
+  let methods = updaterMethods();
+  for (let updater of updaters) {
+    updater(methods);
+  }
+}
+export { getGlobalConfig as g };

package/dist/unpkg/dev/signals/-leaked.js

@@ -0,0 +1 @@
+export { D as DISPOSE, d as defineGate, q as defineNonEnumerableSignal, f as defineSignal, h as entangleSignal, t as gate, u as memoized, n as notifyInternalSignal, p as peekInternalSignal, r as signal, o as waitFor, w as withSignalStore } from "../-leaked-Co0EI6Go.js";

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

@@ -0,0 +1,55 @@
+import '../types/request.js';
+import { i as isResourceKey, c as coerceId } from "../index-BzcBOnw9.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, j as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, g as assertPrivateCapabilities, b as assertPrivateStore, k as createLegacyManyArray, e as ensureStringId, f as fastPush, d as isPrivateStore, a as isRequestKey, l as log, m as logGroup, r as recordIdentifierFor, h as setRecordIdentifier, s as storeFor } from "../index-BzcBOnw9.js";
+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);
+    }
+    (test => {
+      if (!test) {
+        throw new Error('Expected either id or lid to be a valid string');
+      }
+    })('id' in resource && isNonEmptyString(resource.id) || isNonEmptyString(resource.lid));
+    (test => {
+      if (!test) {
+        throw new Error('if id is present, the type must be a string');
+      }
+    })(!('id' in resource) || typeof resource.type === 'string');
+    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');
+    }
+    (test => {
+      if (!test) {
+        throw new Error('type must be a string');
+      }
+    })(typeof type === 'string');
+    if (isNonEmptyString(lid)) {
+      return {
+        type,
+        id: trueId,
+        lid
+      };
+    }
+    return {
+      type,
+      id: trueId
+    };
+  }
+}
+export { coerceId, constructResource, isResourceKey };