aberdeen 1.17.1 → 2.0.1

package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Default browser entry point for Aberdeen.
+ *
+ * It exports a ready-to-use Aberdeen instance (`A`) bound to the global `window`, so you can
+ * `import A from 'aberdeen'` and start building UI with zero setup. Advanced users (and the
+ * `aberdeen/server` SSR entry) can instead import {@link createA} to create instances bound to a
+ * specific window, including multiple isolated instances.
+ */
+export { createA } from "./aberdeen.js";
+export type { Aberdeen, WindowLike, InitOptions, ValueRef, PromiseProxy } from "./aberdeen.js";
+import { createA } from "./aberdeen.js";
+
+export default createA(typeof window !== "undefined" ? (window as any) : undefined);

package/src/prediction.ts

@@ -1,21 +1,18 @@
-import {
-	defaultEmitHandler,
-	withEmitHandler,
-	EMPTY,
-	MAP_SIZE_SYMBOL,
-} from "./aberdeen.js";
-import type { TargetType } from "./aberdeen.js";
+// This module operates on a specific Aberdeen instance, which is passed as the first argument
+// (`A`) to its public functions. `A` provides the emit handlers and the EMPTY/MAP_SIZE_SYMBOL
+// markers it needs.
+type Aberdeen = any;
 
 /**
  * Represents a set of changes that can be applied to proxied objects.
  * This is an opaque type - its internal structure is not part of the public API.
  * @private
  */
-export type Patch = Map<TargetType, Map<any, [any, any]>>;
+export type Patch = Map<any, Map<any, [any, any]>>;
 
-function recordPatch(func: () => void): Patch {
+function recordPatch(A: Aberdeen, func: () => void): Patch {
 	const recordingPatch = new Map();
-	withEmitHandler((target, index, newData, oldData) => {
+	A.withEmitHandler((target: any, index: any, newData: any, oldData: any) => {
 		addToPatch(recordingPatch, target, index, newData, oldData);
 	}, func);
 	return recordingPatch;
@@ -23,7 +20,7 @@ function recordPatch(func: () => void): Patch {
 
 function addToPatch(
 	patch: Patch,
-	collection: TargetType,
+	collection: any,
 	index: any,
 	newData: any,
 	oldData: any,
@@ -39,10 +36,10 @@ function addToPatch(
 	else collectionMap.set(index, [newData, oldData0]);
 }
 
-function emitPatch(patch: Patch) {
+function emitPatch(A: Aberdeen, patch: Patch) {
 	for (const [collection, collectionMap] of patch) {
 		for (const [index, [newData, oldData]] of collectionMap) {
-			defaultEmitHandler(collection, index, newData, oldData);
+			A.defaultEmitHandler(collection, index, newData, oldData);
 		}
 	}
 }
@@ -61,11 +58,12 @@ function mergePatch(target: Patch, source: Patch, reverse = false) {
 	}
 }
 
-function silentlyApplyPatch(patch: Patch, force = false): boolean {
+function silentlyApplyPatch(A: Aberdeen, patch: Patch, force = false): boolean {
+	const EMPTY = A.EMPTY;
 	for (const [collection, collectionMap] of patch) {
 		for (const [index, [newData, oldData]] of collectionMap) {
 			// MAP_SIZE_SYMBOL is synthetic - size is derived from add/delete operations
-			if (index === MAP_SIZE_SYMBOL) continue;
+			if (index === A.MAP_SIZE_SYMBOL) continue;
 			const actualData =
 				collection instanceof Map
 					? collection.has(index)
@@ -76,7 +74,7 @@ function silentlyApplyPatch(patch: Patch, force = false): boolean {
 						: EMPTY;
 			if (actualData !== oldData) {
 				if (force)
-					setTimeout(() => {
+					(A.window?.setTimeout ?? setTimeout)(() => {
 						throw new Error(
 							`Applying invalid patch: data ${String(actualData)} is unequal to expected old data ${String(oldData)} for index ${String(index)}`,
 						);
@@ -87,7 +85,7 @@ function silentlyApplyPatch(patch: Patch, force = false): boolean {
 	}
 	for (const [collection, collectionMap] of patch) {
 		for (const [index, [newData, oldData]] of collectionMap) {
-			if (index === MAP_SIZE_SYMBOL) continue;
+			if (index === A.MAP_SIZE_SYMBOL) continue;
 			if (collection instanceof Map) {
 				if (newData === EMPTY) collection.delete(index);
 				else collection.set(index, newData);
@@ -106,15 +104,16 @@ const appliedPredictions: Array<Patch> = [];
  * Run the provided function, while treating all changes to Observables as predictions,
  * meaning they will be reverted when changes come back from the server (or some other
  * async source).
+ * @param A The Aberdeen instance (the default export of `aberdeen`, or one from `init`).
  * @param predictFunc The function to run. It will generally modify some Observables
  * 	to immediately reflect state (as closely as possible) that we expect the server
  *  to communicate back to us later on.
  * @returns A `Patch` object. Don't modify it. This is only meant to be passed to `applyCanon`.
  */
-export function applyPrediction(predictFunc: () => void): Patch {
-	const patch = recordPatch(predictFunc);
+export function applyPrediction(A: Aberdeen, predictFunc: () => void): Patch {
+	const patch = recordPatch(A, predictFunc);
 	appliedPredictions.push(patch);
-	emitPatch(patch);
+	emitPatch(A, patch);
 	return patch;
 }
 
@@ -127,6 +126,7 @@ export function applyPrediction(predictFunc: () => void): Patch {
  *
  * All of this is done such that redraws are only triggered if the overall effect is an
  * actual change to an `Observable`.
+ * @param A The Aberdeen instance (the default export of `aberdeen`, or one from `init`).
  * @param canonFunc The function to run without any predictions applied. This will typically
  *  make authoritative changes to the data, based on a server response.
  * @param dropPredictions An optional list of predictions (as returned by `applyPrediction`)
@@ -134,22 +134,23 @@ export function applyPrediction(predictFunc: () => void): Patch {
  *  you'd want to drop the prediction that was done for that request.
  */
 export function applyCanon(
+	A: Aberdeen,
 	canonFunc?: () => void,
 	dropPredictions: Array<Patch> = [],
 ) {
 	const resultPatch = new Map();
 	for (const prediction of appliedPredictions)
 		mergePatch(resultPatch, prediction, true);
-	silentlyApplyPatch(resultPatch, true);
+	silentlyApplyPatch(A, resultPatch, true);
 
 	for (const prediction of dropPredictions) {
 		const pos = appliedPredictions.indexOf(prediction);
 		if (pos >= 0) appliedPredictions.splice(pos, 1);
 	}
-	if (canonFunc) mergePatch(resultPatch, recordPatch(canonFunc));
+	if (canonFunc) mergePatch(resultPatch, recordPatch(A, canonFunc));
 
 	for (let idx = 0; idx < appliedPredictions.length; idx++) {
-		if (silentlyApplyPatch(appliedPredictions[idx])) {
+		if (silentlyApplyPatch(A, appliedPredictions[idx])) {
 			mergePatch(resultPatch, appliedPredictions[idx]);
 		} else {
 			appliedPredictions.splice(idx, 1);
@@ -157,5 +158,5 @@ export function applyCanon(
 		}
 	}
 
-	emitPatch(resultPatch);
+	emitPatch(A, resultPatch);
 }