@warp-drive/core 5.9.0-alpha.3 → 5.9.0-alpha.31

package/dist/-private-CFGb9QrK.js

@@ -0,0 +1,22 @@
+import { t as getOrSetGlobal } from "./-private-c45j0xNN.js";
+
+//#region src/reactive/-private/symbols.ts
+const SOURCE = getOrSetGlobal("SOURCE", Symbol("#source"));
+const Destroy = getOrSetGlobal("Destroy", Symbol.dispose || Symbol.for("Dispose"));
+/**
+* Symbol for the method used to request a mutable copy of an otherwise
+* immutable {@link ReactiveResource}.
+*
+* @deprecated use the {@link checkout} utility function instead.
+*/
+const Checkout = getOrSetGlobal("Checkout", Symbol("Checkout"));
+const Commit = getOrSetGlobal("Commit", Symbol("Commit"));
+/**
+* Symbol used to stash the internal field/resource context (schema, store,
+* mutability, etc.) on a {@link ReactiveResource} or reactive field instance.
+*/
+const Context = getOrSetGlobal("Context", Symbol("Context"));
+
+//#endregion
+export { SOURCE as a, Destroy as i, Commit as n, Context as r, Checkout as t };
+//# sourceMappingURL=-private-CFGb9QrK.js.map

package/dist/-private-CFGb9QrK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"-private-CFGb9QrK.js","names":["getOrSetGlobal","SOURCE","Symbol","Destroy","dispose","for","Checkout","Commit","Context"],"sources":["../src/reactive/-private/symbols.ts"],"sourcesContent":["///////////////////\n///// WARNING /////\n///////////////////\n\nimport { getOrSetGlobal } from '../../types/-private';\n\n// Great, got your attention with that warning didn't we?\n// Good. Here's the deal: typescript treats symbols as unique types.\n// If by accident a module creating a symbol is processed more than\n// once, the symbol will be different in each processing. This will\n// cause a type error.\n// It could also cause a runtime error if the symbol is used innapropriately.\n// However, this case is extremely hard to hit and would require other things\n// to go wrong first.\n//\n// So, why do the warning? And why do we lie about the types of the symbols?\n//\n// Because we intentionally create multiple copies of them within the types\n// at build time. This is because we rollup our d.ts files in order to give\n// our consumers a better experience.\n//\n// However, no tool today supports rolling up d.ts files with multiple entry\n// points correctly. The tool we use currently (vite-plugin-dts) uses @microsoft/api-extractor\n// which creates a fully unique stand-alone types file per-entry-point. Thus\n// every entry point that uses one of these symbols somewhere will have accidentally\n// created a new symbol type.\n//\n// This cast allows us to rollup these types using this tool while not encountering\n// the unique symbol type issue.\n//\n// Note that none of these symbols are part of the public API, these are used for\n// debugging DX and as a safe way to provide an intimate contract on public objects.\n\nexport const SOURCE: '___(unique) Symbol(SOURCE)' = getOrSetGlobal('SOURCE', Symbol('#source'));\n\nexport const Destroy: '___(unique) Symbol(Destroy)' = getOrSetGlobal(\n  'Destroy',\n  Symbol.dispose || Symbol.for('Dispose')\n);\n/**\n * Symbol for the method used to request a mutable copy of an otherwise\n * immutable {@link ReactiveResource}.\n *\n * @deprecated use the {@link checkout} utility function instead.\n */\nexport const Checkout: '___(unique) Symbol(Checkout)' = getOrSetGlobal('Checkout', Symbol('Checkout'));\nexport const Commit: '___(unique) Symbol(Commit)' = getOrSetGlobal('Commit', Symbol('Commit'));\n\n/**\n * Symbol used to stash the internal field/resource context (schema, store,\n * mutability, etc.) on a {@link ReactiveResource} or reactive field instance.\n */\nexport const Context: '___(unique) Symbol(Context)' = getOrSetGlobal('Context', Symbol('Context'));\n"],"mappings":";;;AAiCA,MAAaC,SAAuCD,eAAe,UAAUE,OAAO,SAAS,CAAC;AAE9F,MAAaC,UAAyCH,eACpD,WACAE,OAAOE,WAAWF,OAAOG,IAAI,SAAS,CACxC;;;;;;;AAOA,MAAaC,WAA2CN,eAAe,YAAYE,OAAO,UAAU,CAAC;AACrG,MAAaK,SAAuCP,eAAe,UAAUE,OAAO,QAAQ,CAAC;;;;;AAM7F,MAAaM,UAAyCR,eAAe,WAAWE,OAAO,SAAS,CAAC"}

package/dist/-private-c45j0xNN.js

@@ -0,0 +1,120 @@
+import { getGlobalConfig, macroCondition } from "@embroider/macros";
+
+//#region package.json
+var name = "@warp-drive/core";
+var version = "5.9.0-alpha.31";
+
+//#endregion
+//#region src/types/-private.ts
+const GlobalRef = globalThis;
+const UniversalCache = GlobalRef.__warpDrive_universalCache = GlobalRef.__warpDrive_universalCache ?? {};
+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 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;
+}
+/**
+* Coordinates creation of a singleton `value` (e.g. a symbol, WeakMap, or
+* error class) for `key` so that duplicate copies of this package loaded
+* into the same process observe the same instance instead of each creating
+* their own.
+*
+* In `TESTING` builds this stores/reads `value` from a cache namespaced to
+* this package's name on `globalThis` (see the file-level comments above for
+* why this is necessary). Outside of `TESTING`, only one copy of the package
+* is expected to exist, so this is a no-op that always returns `value`
+* unchanged.
+*
+* The return type lies about symbols being unique to work around the d.ts
+* rollup issue described in `reactive/-private/symbols.ts`.
+*
+* @private
+*/
+function getOrSetGlobal(key, value) {
+	if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+		const existing = ModuleScopedCaches[key];
+		if (existing === void 0) return ModuleScopedCaches[key] = value;
+		else return existing;
+	} else return value;
+}
+/**
+* Reads back the current value stored for `key` by {@link setTransient}, or
+* `null` if nothing has been stored yet.
+*
+* Unlike {@link getOrSetGlobal}, this always reads through the same
+* package-namespaced cache regardless of the `TESTING` flag, since this is
+* used for genuinely mutable state (not just singleton values) that must
+* stay in sync across any duplicate copies of this package.
+*
+* @private
+*/
+function peekTransient(key) {
+	const globalKey = `(transient) ${key}`;
+	return ModuleScopedCaches[globalKey] ?? null;
+}
+/**
+* Stores `value` for `key`, overwriting whatever was previously stored, so
+* that it can later be read back via {@link peekTransient}.
+*
+* See {@link peekTransient} for details on when/why this cache is shared.
+*
+* @private
+*/
+function setTransient(key, value) {
+	const globalKey = `(transient) ${key}`;
+	return ModuleScopedCaches[globalKey] = value;
+}
+/**
+* Like {@link getOrSetGlobal}, but reads/writes a cache that is shared across
+* *all* copies of WarpDrive on `globalThis`, regardless of package name.
+*
+* This is used for keys (e.g. request/promise caches) that must be
+* coordinated even across "mirror" packages published under different
+* names, rather than only across duplicate copies of the same package name.
+*
+* @private
+*/
+function getOrSetUniversal(key, value) {
+	if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+		const existing = UniversalCache[key];
+		if (existing === void 0) return UniversalCache[key] = value;
+		else return existing;
+	} else return value;
+}
+/**
+* Like {@link peekTransient}, but reads from the package-name-independent
+* cache used by {@link getOrSetUniversal}. Always reads through this shared
+* cache regardless of the `TESTING` flag.
+*
+* @private
+*/
+function peekUniversalTransient(key) {
+	const globalKey = `(transient) ${key}`;
+	return UniversalCache[globalKey] ?? null;
+}
+/**
+* Like {@link setTransient}, but writes to the package-name-independent
+* cache used by {@link getOrSetUniversal}, so it can later be read via
+* {@link peekUniversalTransient}.
+*
+* @private
+*/
+function setUniversalTransient(key, value) {
+	const globalKey = `(transient) ${key}`;
+	return UniversalCache[globalKey] = value;
+}
+
+//#endregion
+export { setTransient as a, peekUniversalTransient as i, getOrSetUniversal as n, setUniversalTransient as o, peekTransient as r, getOrSetGlobal as t };
+//# sourceMappingURL=-private-c45j0xNN.js.map

package/dist/-private-c45j0xNN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"-private-c45j0xNN.js","names":["name","version","getGlobalConfig","macroCondition","GlobalRef","globalThis","UniversalCache","__warpDrive_universalCache","__version","GlobalSink","WarpDrive","env","DEBUG","Error","ModuleScopedCaches","__warpDrive_ModuleScopedCaches","TESTING","console","warn","__warpDrive_hasOtherCopy","getOrSetGlobal","key","value","existing","undefined","peekTransient","globalKey","setTransient","getOrSetUniversal","peekUniversalTransient","setUniversalTransient"],"sources":["../package.json","../src/types/-private.ts"],"sourcesContent":["","// in testing mode, we utilize globals to ensure only one copy exists of\n// these maps, due to bugs in ember-auto-import\nimport { DEBUG, TESTING } from '@warp-drive/core/build-config/env';\n\nimport { name, version } from '../../package.json';\n\ntype UniversalTransientKey =\n  // @warp-drive/core/request\n  'REQ_ID';\n\ntype UniversalKey =\n  | `(transient) ${UniversalTransientKey}`\n  // @warp-drive/core/request\n  | 'RequestMap'\n  | 'PromiseCache'\n  | 'RequestCache'\n  // @warp-drive/core-types/request\n  | 'SkipCache'\n  | 'EnableHydration'\n  // @warp-drive/core-types/runtime\n  | 'WarpDriveRuntimeConfig';\n\ntype TransientKey =\n  // @warp-drive/core/graph\n  | 'transactionRef'\n  // @warp-drive/core/store\n  | 'configuredGenerationMethod'\n  | 'configuredUpdateMethod'\n  | 'configuredForgetMethod'\n  | 'configuredResetMethod'\n  | 'configuredKeyInfoMethod'\n  | 'signalHooks';\n\ntype GlobalKey =\n  | `(transient) ${TransientKey}`\n  // @warp-drive/legacy/adapter\n  | 'AdapterError'\n  | 'InvalidError'\n  | 'TimeoutError'\n  | 'AbortError'\n  | 'UnauthorizedError'\n  | 'ForbiddenError'\n  | 'NotFoundError'\n  | 'ConflictError'\n  | 'ServerError'\n  // @warp-drive/core/store/reactivity\n  | '#{}'\n  | '#[]'\n  | 'Signals'\n  // @warp-drive/legacy LegacySupport\n  | 'AvailableShims'\n  // @warp-drive/core RecordArrayManager\n  | 'FAKE_ARR'\n  // @warp-drive/core ReactiveArray\n  | '#source'\n  | '#update'\n  | '#notify'\n  | 'IS_COLLECTION'\n  // @warp-drive/core RequestCache\n  | 'Touching'\n  | 'RequestPromise'\n  // @warp-drive/legacy/compat FetchManager\n  | 'SaveOp'\n  // @warp-drive/legacy Model\n  | 'LEGACY_SUPPORT'\n  | 'LegacySupport'\n  // @warp-drive/core/graph\n  | 'Graphs'\n  // @warp-drive/core/request\n  | 'IS_FROZEN'\n  | 'IS_CACHE_HANDLER'\n  // @warp-drive/utilities\n  | 'CONFIG'\n  // @warp-drive/core CacheKeyManager\n  | 'DEBUG_MAP'\n  | 'IDENTIFIERS'\n  | 'DOCUMENTS'\n  // @warp-drive/core InstanceCache\n  | 'RecordCache'\n  | 'StoreMap'\n  // @warp-drive/core/types/symbols\n  | 'Store'\n  | '$type'\n  | 'TransformName'\n  | 'RequestSignature'\n  // @warp-drive/core/types/request\n  | 'IS_FUTURE'\n  | 'DOC'\n  // @warp-drive/core NotificationManager\n  | 'UnscopedChannel'\n  // @warp-drive/core/reactive\n  | 'ManagedArrayMap'\n  | 'ManagedObjectMap'\n  | 'Support'\n  | 'SOURCE'\n  | 'Destroy'\n  | 'Checkout'\n  | 'Commit'\n  | 'Context';\n\ntype ModuleScopedCaches = Record<GlobalKey, unknown>;\n\nconst GlobalRef = globalThis as unknown as Record<\n  string,\n  {\n    __warpDrive_ModuleScopedCaches?: ModuleScopedCaches;\n    __warpDrive_hasOtherCopy?: boolean;\n    __version: string;\n  }\n> & {\n  __warpDrive_universalCache: Record<UniversalKey, unknown>;\n};\nconst UniversalCache = (GlobalRef.__warpDrive_universalCache =\n  GlobalRef.__warpDrive_universalCache ?? ({} as Record<UniversalKey, unknown>));\n\n// in order to support mirror packages, we ensure that each\n// unique package name has its own global cache\nGlobalRef[name] = GlobalRef[name] ?? { __version: version };\nconst GlobalSink = GlobalRef[name];\n\nif (DEBUG) {\n  if (GlobalSink.__version !== version) {\n    throw new Error('Multiple versions of WarpDrive detected, the application will malfunction.');\n  }\n}\n\nconst ModuleScopedCaches = GlobalSink.__warpDrive_ModuleScopedCaches ?? ({} as ModuleScopedCaches);\nif (TESTING) {\n  if (!GlobalSink.__warpDrive_ModuleScopedCaches) {\n    GlobalSink.__warpDrive_ModuleScopedCaches = ModuleScopedCaches;\n  } else {\n    // oxlint-disable-next-line no-console\n    console.warn(`\nMultiple copies of WarpDrive have been detected. This may be due to a bug in ember-auto-import\n  in which test assets get their own copy of some v2-addons. This can cause the application to\n  malfunction as each copy will maintain its own separate state.`);\n  }\n} else {\n  if (GlobalSink.__warpDrive_hasOtherCopy) {\n    throw new Error('Multiple copies of WarpDrive detected, the application will malfunction.');\n  }\n  GlobalSink.__warpDrive_hasOtherCopy = true;\n}\n\ntype UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;\ntype UniqueSymbolOr<T, K extends string> = T extends symbol ? UniqueSymbol<K> : T;\n\n/**\n * Coordinates creation of a singleton `value` (e.g. a symbol, WeakMap, or\n * error class) for `key` so that duplicate copies of this package loaded\n * into the same process observe the same instance instead of each creating\n * their own.\n *\n * In `TESTING` builds this stores/reads `value` from a cache namespaced to\n * this package's name on `globalThis` (see the file-level comments above for\n * why this is necessary). Outside of `TESTING`, only one copy of the package\n * is expected to exist, so this is a no-op that always returns `value`\n * unchanged.\n *\n * The return type lies about symbols being unique to work around the d.ts\n * rollup issue described in `reactive/-private/symbols.ts`.\n *\n * @private\n */\nexport function getOrSetGlobal<T, K extends GlobalKey>(key: K, value: T): UniqueSymbolOr<T, K> {\n  if (TESTING) {\n    const existing = ModuleScopedCaches[key];\n    if (existing === undefined) {\n      return (ModuleScopedCaches[key] = value) as UniqueSymbolOr<T, K>;\n    } else {\n      return existing as UniqueSymbolOr<T, K>;\n    }\n  } else {\n    return value as UniqueSymbolOr<T, K>;\n  }\n}\n\n/**\n * Reads back the current value stored for `key` by {@link setTransient}, or\n * `null` if nothing has been stored yet.\n *\n * Unlike {@link getOrSetGlobal}, this always reads through the same\n * package-namespaced cache regardless of the `TESTING` flag, since this is\n * used for genuinely mutable state (not just singleton values) that must\n * stay in sync across any duplicate copies of this package.\n *\n * @private\n */\nexport function peekTransient<T>(key: TransientKey): T | null {\n  const globalKey: `(transient) ${TransientKey}` = `(transient) ${key}`;\n  return (ModuleScopedCaches[globalKey] as T) ?? null;\n}\n\n/**\n * Stores `value` for `key`, overwriting whatever was previously stored, so\n * that it can later be read back via {@link peekTransient}.\n *\n * See {@link peekTransient} for details on when/why this cache is shared.\n *\n * @private\n */\nexport function setTransient<T>(key: TransientKey, value: T): T {\n  const globalKey: `(transient) ${TransientKey}` = `(transient) ${key}`;\n  return (ModuleScopedCaches[globalKey] = value);\n}\n\n/**\n * Like {@link getOrSetGlobal}, but reads/writes a cache that is shared across\n * *all* copies of WarpDrive on `globalThis`, regardless of package name.\n *\n * This is used for keys (e.g. request/promise caches) that must be\n * coordinated even across \"mirror\" packages published under different\n * names, rather than only across duplicate copies of the same package name.\n *\n * @private\n */\nexport function getOrSetUniversal<T, K extends UniversalKey>(key: K, value: T): UniqueSymbolOr<T, K> {\n  if (TESTING) {\n    const existing = UniversalCache[key];\n    if (existing === undefined) {\n      return (UniversalCache[key] = value) as UniqueSymbolOr<T, K>;\n    } else {\n      return existing as UniqueSymbolOr<T, K>;\n    }\n  } else {\n    return value as UniqueSymbolOr<T, K>;\n  }\n}\n\n/**\n * Like {@link peekTransient}, but reads from the package-name-independent\n * cache used by {@link getOrSetUniversal}. Always reads through this shared\n * cache regardless of the `TESTING` flag.\n *\n * @private\n */\nexport function peekUniversalTransient<T>(key: UniversalTransientKey): T | null {\n  const globalKey: `(transient) ${UniversalTransientKey}` = `(transient) ${key}`;\n  return (UniversalCache[globalKey] as T) ?? null;\n}\n\n/**\n * Like {@link setTransient}, but writes to the package-name-independent\n * cache used by {@link getOrSetUniversal}, so it can later be read via\n * {@link peekUniversalTransient}.\n *\n * @private\n */\nexport function setUniversalTransient<T>(key: UniversalTransientKey, value: T): T {\n  const globalKey: `(transient) ${UniversalTransientKey}` = `(transient) ${key}`;\n  return (UniversalCache[globalKey] = value);\n}\n"],"mappings":";;;;;;;;ACsGA,MAAMI,YAAYC;AAUlB,MAAMC,iBAAkBF,UAAUG,6BAChCH,UAAUG,8BAA+B,CAAC;AAI5CH,UAAUJ,QAAQI,UAAUJ,SAAS,EAAEQ,WAAWP,QAAQ;AAC1D,MAAMQ,aAAaL,UAAUJ;AAE7B,IAAAG,eAAAD,gBAAA,CAAA,CAAAQ,UAAAC,IAAAC,KAAA,GACE;KAAIH,WAAWD,cAAcP,SAC3B,MAAM,IAAIY,MAAM,4EAA4E;AAC9F;AAGF,MAAMC,qBAAqBL,WAAWM,kCAAmC,CAAC;AAC1E,IAAAZ,eAAAD,gBAAA,CAAA,CAAAQ,UAAAC,IAAAK,OAAA,GAAa;CACX,IAAI,CAACP,WAAWM,gCACdN,WAAWM,iCAAiCD;MAG5CG,QAAQC,KAAK;;;iEAGgD;AAEjE,OAAO;CACL,IAAIT,WAAWU,0BACb,MAAM,IAAIN,MAAM,0EAA0E;CAE5FJ,WAAWU,2BAA2B;AACxC;;;;;;;;;;;;;;;;;;AAsBA,SAAgBC,eAAuCC,KAAQC,OAAgC;CAC7F,IAAAnB,eAAAD,gBAAA,CAAA,CAAAQ,UAAAC,IAAAK,OAAA,GAAa;EACX,MAAMO,WAAWT,mBAAmBO;EACpC,IAAIE,aAAaC,QACf,OAAQV,mBAAmBO,OAAOC;OAElC,OAAOC;CAEX,OACE,OAAOD;AAEX;;;;;;;;;;;;AAaA,SAAgBG,cAAiBJ,KAA6B;CAC5D,MAAMK,YAA2C,eAAeL;CAChE,OAAQP,mBAAmBY,cAAoB;AACjD;;;;;;;;;AAUA,SAAgBC,aAAgBN,KAAmBC,OAAa;CAC9D,MAAMI,YAA2C,eAAeL;CAChE,OAAQP,mBAAmBY,aAAaJ;AAC1C;;;;;;;;;;;AAYA,SAAgBM,kBAA6CP,KAAQC,OAAgC;CACnG,IAAAnB,eAAAD,gBAAA,CAAA,CAAAQ,UAAAC,IAAAK,OAAA,GAAa;EACX,MAAMO,WAAWjB,eAAee;EAChC,IAAIE,aAAaC,QACf,OAAQlB,eAAee,OAAOC;OAE9B,OAAOC;CAEX,OACE,OAAOD;AAEX;;;;;;;;AASA,SAAgBO,uBAA0BR,KAAsC;CAC9E,MAAMK,YAAoD,eAAeL;CACzE,OAAQf,eAAeoB,cAAoB;AAC7C;;;;;;;;AASA,SAAgBI,sBAAyBT,KAA4BC,OAAa;CAChF,MAAMI,YAAoD,eAAeL;CACzE,OAAQf,eAAeoB,aAAaJ;AACtC"}

package/dist/aliases-BWYW5EhX.d.ts

@@ -0,0 +1,17 @@
+//#region src/types/cache/aliases.d.ts
+/**
+ * The `ResourceBlob` is an opaque type that must satisfy two constraints.
+ *
+ * 1. it should be possible for the {@link CacheKeyManager} to be able to
+ *    generate a {@link ResourceKey} for it, whether by default or due to
+ *    configuration.
+ * 2. it should be in a format expected by the {@link Cache}. This format
+ *    is {@link Cache}-declared.
+ *
+ * This opaqueness allows arbitrary storage of any serializable/transferable
+ * state, including such things as `Buffer`s and `String`s.
+ */
+type ResourceBlob = unknown;
+//#endregion
+export { ResourceBlob as t };
+//# sourceMappingURL=aliases-BWYW5EhX.d.ts.map

package/dist/aliases-BWYW5EhX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliases-BWYW5EhX.d.ts","names":[],"sources":["../src/types/cache/aliases.ts"],"mappings":";;;;;;;;;;;;;KAmBY"}

package/dist/build-config/babel-macros.d.ts

@@ -0,0 +1,2 @@
+import { macros } from "@warp-drive/build-config/babel-macros";
+export { macros };

package/dist/build-config/babel-macros.js

@@ -1 +1,3 @@
-export { macros } from '@warp-drive/build-config/babel-macros';
+import { macros } from "@warp-drive/build-config/babel-macros";
+
+export { macros };

package/dist/build-config/canary-features.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/canary-features";

package/dist/build-config/canary-features.js

@@ -1 +1 @@
-export * from '@warp-drive/build-config/canary-features';
+export * from "@warp-drive/build-config/canary-features"

package/dist/build-config/debugging.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/debugging";

package/dist/build-config/debugging.js

@@ -1 +1 @@
-export * from '@warp-drive/build-config/debugging';
+export * from "@warp-drive/build-config/debugging"

package/dist/build-config/deprecations.d.ts

@@ -0,0 +1 @@
+export * from "@warp-drive/build-config/deprecations";

package/dist/build-config/deprecations.js

@@ -1 +1 @@
-export * from '@warp-drive/build-config/deprecations';
+export * from "@warp-drive/build-config/deprecations"

package/dist/build-config/env.d.ts

@@ -0,0 +1,2 @@
+import { DEBUG, IS_CI, IS_RECORDING, PRODUCTION, SHOULD_RECORD, TESTING } from "@warp-drive/build-config/env";
+export { DEBUG, IS_CI, IS_RECORDING, PRODUCTION, SHOULD_RECORD, TESTING };

package/dist/build-config/env.js

@@ -1 +1,3 @@
-export { DEBUG, IS_CI, IS_RECORDING, PRODUCTION, SHOULD_RECORD, TESTING } from '@warp-drive/build-config/env';
+import { DEBUG, IS_CI, IS_RECORDING, PRODUCTION, SHOULD_RECORD, TESTING } from "@warp-drive/build-config/env";
+
+export { DEBUG, IS_CI, IS_RECORDING, PRODUCTION, SHOULD_RECORD, TESTING };

package/dist/build-config/macros.d.ts

@@ -0,0 +1,2 @@
+import { assert } from "@warp-drive/build-config/macros";
+export { assert };

package/dist/build-config/macros.js

@@ -1 +1,3 @@
-export { assert } from '@warp-drive/build-config/macros';
+import { assert } from "@warp-drive/build-config/macros";
+
+export { assert };

package/dist/build-config.d.ts

@@ -0,0 +1,2 @@
+import { WarpDriveConfig, babelPlugin, setConfig } from "@warp-drive/build-config";
+export { type WarpDriveConfig, babelPlugin, setConfig };

package/dist/build-config.js

@@ -1 +1,3 @@
-export { babelPlugin, setConfig } from '@warp-drive/build-config';
+import { babelPlugin, setConfig } from "@warp-drive/build-config";
+
+export { babelPlugin, setConfig };

package/dist/change-C7kqv2kW.d.ts

@@ -0,0 +1,41 @@
+import { c as RequestKey, l as ResourceKey } from "./identifier-DQnqOSJK.js";
+//#region src/types/cache/change.d.ts
+/**
+ * Describes a single mutation to a resource or document that occurred
+ * in the cache, as returned by {@link Cache.diff}.
+ *
+ * @example
+ * ```ts
+ * const change: Change = {
+ *   identifier: resourceKey,
+ *   op: 'upsert',
+ *   patch: { name: 'Chris' },
+ * };
+ * ```
+ */
+interface Change {
+  /**
+   * the {@link ResourceKey} or {@link RequestKey} of the entity that changed
+   */
+  identifier: ResourceKey | RequestKey;
+  /**
+   * the type of change that occurred. If `'upsert'`, {@link Change.patch | patch}
+   * will be present with the data to merge into the cache for the entity.
+   */
+  op: "upsert" | "remove";
+  /**
+   * When {@link Change.op | op} is `'upsert'`, the data to merge into the
+   * cache for the entity.
+   *
+   * This is opaque to the Store but should be understood by the Cache and
+   * may be utilized by an Adapter when generating data during a `save`
+   * operation.
+   *
+   * It is generally recommended that `patch` contain only the updated
+   * state, ignoring fields that are unchanged.
+   */
+  patch?: unknown;
+}
+//#endregion
+export { Change as t };
+//# sourceMappingURL=change-C7kqv2kW.d.ts.map

package/dist/change-C7kqv2kW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-C7kqv2kW.d.ts","names":[],"sources":["../src/types/cache/change.ts"],"mappings":";;;;;;;;;;;;;;;UAiBiB;;;;EAIf,YAAY,cAAc;;;;;EAK1B;;;;;;;;;;;;EAYA"}

package/dist/concepts-DFldVwEM.d.ts

@@ -0,0 +1,77 @@
+import { l as ResourceKey } from "./identifier-DQnqOSJK.js";
+import { a as Type } from "./symbols-DjRDCeX0.js";
+import { i as OpaqueRecordInstance } from "./record-D3QQcaIR.js";
+import { i as Value, n as ObjectValue } from "./raw-D5hnjiq7.js";
+//#region src/types/schema/concepts.d.ts
+/**
+ * A Transformation converts a cached primitive value into a richer
+ * "presentation" value exposed on a record, and back again.
+ *
+ * Transformations are used by {@link GenericField}, {@link ObjectField}
+ * and {@link ArrayField} to convert between the raw value stored in the
+ * cache (`T`) and the value read from or written to a record (`PT`).
+ *
+ * Transformations must be registered with the SchemaService via
+ * `schema.registerTransformation(transform)` before use, keyed by the
+ * name assigned to their {@link Type} property.
+ */
+type Transformation<T extends Value = Value, PT = unknown> = {
+  /**
+   * Converts a value from its presentation form (as read from or written
+   * to a record) into the raw form to be stored in the cache.
+   */
+  serialize(value: PT, options: ObjectValue | null, record: OpaqueRecordInstance): T;
+  /**
+   * Converts a value from its raw cached form into the presentation
+   * form exposed on a record.
+   */
+  hydrate(value: T | undefined, options: ObjectValue | null, record: OpaqueRecordInstance): PT;
+  /**
+   * Computes the value to use when no value is present in the cache
+   * for the field.
+   */
+  defaultValue?(options: ObjectValue | null, identifier: ResourceKey): T;
+  /**
+   * The unique name this transformation is registered under.
+   */
+  [Type]: string;
+};
+/**
+ * A Derivation computes a read-only field value from other fields
+ * (and options) on a record.
+ *
+ * Derivations back {@link DerivedField}. They are memoized and only
+ * recomputed when the fields they read change; derived values are never
+ * stored in the cache nor sent to the server.
+ *
+ * Derivations must be registered with the SchemaService via
+ * `schema.registerDerivation(derivation)` before use, keyed by the
+ * name assigned to their {@link Type} property.
+ */
+type Derivation<R = unknown, T = unknown, FM extends ObjectValue | null = ObjectValue | null> = {
+  /**
+   * The unique name this derivation is registered under.
+   */
+  [Type]: string;
+} & ((record: R, options: FM, prop: string) => T);
+/**
+ * A HashFn computes a stable string identity for an object from its
+ * cache data, without access to a record instance.
+ *
+ * HashFns back {@link HashField}, and are used to compute the `@hash`
+ * identity of a schema-object, or to determine the resource type of a
+ * polymorphic schema-object or schema-array member.
+ *
+ * HashFns must be registered with the SchemaService via
+ * `schema.registerHashFn(hashFn)` before use, keyed by the name
+ * assigned to their {@link Type} property.
+ */
+type HashFn<T extends object = object> = {
+  /**
+   * The unique name this hash function is registered under.
+   */
+  [Type]: string;
+} & ((data: T, options: ObjectValue | null, prop: string | null) => string);
+//#endregion
+export { HashFn as n, Transformation as r, Derivation as t };
+//# sourceMappingURL=concepts-DFldVwEM.d.ts.map

package/dist/concepts-DFldVwEM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concepts-DFldVwEM.d.ts","names":[],"sources":["../src/types/schema/concepts.ts"],"mappings":";;;;;;;;;;;;;;;;;KAiBY,eAAe,UAAU,QAAQ,OAAO;;;;;EAKlD,UAAU,OAAO,IAAI,SAAS,oBAAoB,QAAQ,uBAAuB;;;;;EAMjF,QAAQ,OAAO,eAAe,SAAS,oBAAoB,QAAQ,uBAAuB;;;;;EAM1F,cAAc,SAAS,oBAAoB,YAAY,cAAc;;;;GAKpE;;;;;;;;;;;;;;KAeS,WAAW,aAAa,aAAa,WAAW,qBAAqB;;;;GAI9E;MACG,QAAQ,GAAG,SAAS,IAAI,iBAAiB;;;;;;;;;;;;;KAcnC,OAAO;;;;GAIhB;MACG,MAAM,GAAG,SAAS,oBAAoB"}

package/dist/configure-B_F639tN.d.ts

@@ -0,0 +1,134 @@
+//#region src/signals/reactivity/configure.d.ts
+declare const ARRAY_SIGNAL: "___(unique) Symbol(#[])";
+/**
+ * An Opaque type that represents a framework specific or TC39 signal.
+ *
+ * It may be an array of signals or a single signal.
+ *
+ * @private
+ */
+type SignalRef = unknown;
+/**
+ * The hooks which MUST be configured in order to use reactive arrays,
+ * resources and documents with framework specfic signals or TC39 signals.
+ *
+ * Support for multiple frameworks simultaneously can be done via
+ * this abstraction by returning multiple signals from the `createSignal`
+ * method, and consuming the correct one via the correct framework via
+ * the `consumeSignal` and `notifySignal` methods.
+ *
+ * Unlike many signals implementations, WarpDrive does not wrap values as
+ * signals directly, but instead uses signals to alert the reactive layer
+ * to changes in the underlying cache. E.g. a signal is associated to a value,
+ * but does not serve as the cache for that value directly. We refer to this as
+ * a "gate", the pattern has also been called "side-signals".
+ *
+ * A no-op implementation is allowed, though it may lead to performance issues
+ * in locations that use createMemo as no memoization would be done. This is
+ * typically desirable only when integrating with a framework that does its own
+ * memoization and does not integrate with any signals-like primitive. For these
+ * scenarios you may also be interested in integrating with the {@link NotificationManager}
+ * more directly.
+ *
+ * @public
+ */
+interface SignalHooks<T = SignalRef> {
+  /**
+   * Create a signal for the given key associated to the given object.
+   *
+   * This method does *not* need to cache the signal, it will only be
+   * called once for a given object and key. However, if your framework
+   * will look for a signal cache on the object in a given location or may
+   * have created its own signal on the object for some reason it may be
+   * useful to ensure such cache is properly updated.
+   */
+  createSignal: (obj: object, key: string | symbol) => T;
+  /**
+   * Consume (mark as acccessed) a signal previously created via createSignal.
+   */
+  consumeSignal: (signal: T) => void;
+  /**
+   * Alert a signal previously created via createSignal that its associated value has changed.
+   */
+  notifySignal: (signal: T) => void;
+  /**
+   * Take the given function and wrap it in signals-based memoization. Analagous
+   * to a Computed in the TC39 spec.
+   *
+   * Should return a function which when run provides the latest value of the original
+   * function.
+   */
+  createMemo: <F>(obj: object, key: string | symbol, fn: () => F) => () => F;
+  /**
+   * If the signals implementation allows synchronous flushing of watchers, and
+   * has scheduled such a flush (e.g. watchers will run before the current calling
+   * context yields) this should return "true".
+   *
+   * This is generally something that should return false for anything but the few
+   * frameworks that extensively handle their own reactivity => render scheduling.
+   *
+   * For an example, see EmberJS's backburner scheduler which functioned as a microtask
+   * polyfill.
+   */
+  willSyncFlushWatchers: () => boolean;
+  /**
+   * An optional method that allows wrapping key promises within WarpDrive
+   * for things like test-waiters.
+   */
+  waitFor?: <K>(promise: Promise<K>) => Promise<K>;
+}
+/**
+ * Contains information a {@link SignalHooks} implementation may want
+ * to use, such as the specialized key used for the signal
+ * representing an array's contents / length.
+ *
+ * ```ts
+ * interface HooksOptions {
+ *   wellknown: {
+ *     Array: symbol | string;
+ *   }
+ * }
+ * ```
+ *
+ * @public
+ */
+interface HooksOptions {
+  /**
+   * A list of specialized symbols/strings
+   * used by WarpDrive to encapsulate key
+   * reactivity concerns.
+   */
+  wellknown: {
+    /**
+     * The key used when the signal provides reactivity for the
+     * `length` or "contents" of an array.
+     *
+     * Arrays only use a single signal for all accesses, regardless
+     * of index, property or method: this one.
+     */
+    Array: symbol | string;
+  };
+}
+/**
+ * Configures the signals implementation to use. Supports multiple
+ * implementations simultaneously.
+ *
+ * See {@link HooksOptions} for the options passed to the provided function
+ * when called.
+ *
+ * See {@link SignalHooks} for the implementation the callback function should
+ * return.
+ *
+ * @public
+ * @param buildConfig - a function that takes options and returns a configuration object
+ */
+declare function setupSignals<T>(buildConfig: (options: HooksOptions) => SignalHooks<T>): void;
+/**
+ * Wraps `promise` using the configured {@link SignalHooks.waitFor}, if any,
+ * for things like test-waiters. Returns `promise` unchanged if no
+ * `waitFor` hook is configured.
+ */
+declare function waitFor<K>(promise: Promise<K>): Promise<K>;
+//#endregion
+export { setupSignals as a, SignalRef as i, HooksOptions as n, waitFor as o, SignalHooks as r, ARRAY_SIGNAL as t };
+//# sourceMappingURL=configure-B_F639tN.d.ts.map

package/dist/configure-B_F639tN.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure-B_F639tN.d.ts","names":[],"sources":["../src/signals/reactivity/configure.ts"],"mappings":";cAMa;;;;;;;;KAsCD;;;;;;;;;;;;;;;;;;;;;;;;;UAyBK,YAAY,IAAI;;;;;;;;;;EAU/B,eAAe,aAAa,yBAAyB;;;;EAIrD,gBAAgB,QAAQ;;;;EAIxB,eAAe,QAAQ;;;;;;;;EAQvB,aAAa,GAAG,aAAa,sBAAsB,UAAU,YAAY;;;;;;;;;;;;EAazE;;;;;EAMA,WAAW,GAAG,SAAS,QAAQ,OAAO,QAAQ;;;;;;;;;;;;;;;;;UAkB/B;;;;;;EAMf;;;;;;;;IAQE;;;;;;;;;;;;;;;;iBAiBY,aAAa,GAAG,cAAc,SAAS,iBAAiB,YAAY;;;;;;iBAgEpE,QAAQ,GAAG,SAAS,QAAQ,KAAK,QAAQ"}

package/dist/configure.d.ts

@@ -0,0 +1,2 @@
+import { a as setupSignals, n as HooksOptions, r as SignalHooks } from "./configure-B_F639tN.js";
+export { type HooksOptions, type SignalHooks, setupSignals };

package/dist/configure.js

@@ -1,2 +1,3 @@
-export { u as setupSignals } from "./configure-BlQ9ebNX.js";
-import '@embroider/macros';
+import { M as setupSignals } from "./-private-B_RTqxGA.js";
+
+export { setupSignals };